sig
  val fork_exec :
    ?stdin:Core.Std.Unix.File_descr.t ->
    ?stdout:Core.Std.Unix.File_descr.t ->
    ?stderr:Core.Std.Unix.File_descr.t ->
    ?path_lookup:bool ->
    ?env:[ `Extend of (string * string) list
         | `Replace of (string * string) list ] ->
    ?working_dir:string ->
    ?setuid:int -> ?setgid:int -> string -> string list -> Core.Std.Pid.t
  val seteuid : int -> unit
  val setreuid : uid:int -> euid:int -> unit
  external ntohl : Core.Std.Int32.t -> Core.Std.Int32.t = "extended_ml_ntohl"
  external htonl : Core.Std.Int32.t -> Core.Std.Int32.t = "extended_ml_htonl"
  type statvfs = {
    bsize : int;
    frsize : int;
    blocks : int;
    bfree : int;
    bavail : int;
    files : int;
    ffree : int;
    favail : int;
    fsid : int;
    flag : int;
    namemax : int;
  }
  external statvfs : string -> Extended_unix.statvfs = "statvfs_stub"
  external getloadavg : unit -> float * float * float = "getloadavg_stub"
  module Extended_passwd :
    sig
      val of_passwd_line : string -> Core.Std.Unix.Passwd.t option
      val of_passwd_line_exn : string -> Core.Std.Unix.Passwd.t
      val of_passwd_file : string -> Core.Std.Unix.Passwd.t list option
      val of_passwd_file_exn : string -> Core.Std.Unix.Passwd.t list
    end
  external strptime : fmt:string -> string -> Core.Std.Unix.tm
    = "unix_strptime"
  module Inet_port :
    sig
      type t
      val of_int : int -> Extended_unix.Inet_port.t option
      val of_int_exn : int -> Extended_unix.Inet_port.t
      val of_string : string -> Extended_unix.Inet_port.t option
      val of_string_exn : string -> Extended_unix.Inet_port.t
      val to_int : Extended_unix.Inet_port.t -> int
      val to_string : Extended_unix.Inet_port.t -> string
      val t_of_sexp : Sexplib.Sexp.t -> Extended_unix.Inet_port.t
      val sexp_of_t : Extended_unix.Inet_port.t -> Sexplib.Sexp.t
    end
  module Mac_address :
    sig
      type t
      val equal :
        Extended_unix.Mac_address.t -> Extended_unix.Mac_address.t -> bool
      val of_string : string -> Extended_unix.Mac_address.t
      val to_string : Extended_unix.Mac_address.t -> string
      val to_string_cisco : Extended_unix.Mac_address.t -> string
      val hash : t -> int
      val compare : t -> t -> int
      val hashable : t Core.Std.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core.Std.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, 'b, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_, 'b,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_, 'b,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_or_error :
            ('a key_, 'b,
             ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_, 'b,
             get_key:('-> 'a key_) ->
             get_data:('-> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_, 'r,
             get_key:('-> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_or_error :
            ('a key_, 'r,
             get_key:('-> 'a key_) ->
             'r list -> ('a, 'r) t_ Core_kernel.Or_error.t)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, 'r, get_key:('-> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_, 'b,
             get_key:('-> 'a key_) ->
             get_data:('-> 'b) ->
             combine:('-> '-> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'-> f:(key:'a key_ -> data:'-> '-> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'-> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'-> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('-> bool) -> bool
          val for_alli :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'-> bool) -> bool
          val for_all : ('a, 'b) t_ -> f:('-> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'-> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'-> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'-> [ `Duplicate | `Ok ]
          val add_or_error :
            ('a, 'b) t_ ->
            key:'a key_ -> data:'-> unit Core_kernel.Or_error.t
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'-> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'-> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map :
            ('c, ('a, 'b) t_ -> f:('-> 'c) -> ('a, 'c) t_)
            Core_kernel.Core_hashtbl_intf.no_map_options
          val mapi :
            ('c,
             ('a, 'b) t_ -> f:(key:'a key_ -> data:'-> 'c) -> ('a, 'c) t_)
            Core_kernel.Core_hashtbl_intf.no_map_options
          val filter_map :
            ('c, ('a, 'b) t_ -> f:('-> 'c option) -> ('a, 'c) t_)
            Core_kernel.Core_hashtbl_intf.no_map_options
          val filter_mapi :
            ('c,
             ('a, 'b) t_ ->
             f:(key:'a key_ -> data:'-> 'c option) -> ('a, 'c) t_)
            Core_kernel.Core_hashtbl_intf.no_map_options
          val filter : ('a, 'b) t_ -> f:('-> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'-> bool) -> ('a, 'b) t_
          val partition_map :
            ('c,
             ('d,
              ('a, 'b) t_ ->
              f:('-> [ `Fst of '| `Snd of 'd ]) ->
              ('a, 'c) t_ * ('a, 'd) t_)
             Core_kernel.Core_hashtbl_intf.no_map_options)
            Core_kernel.Core_hashtbl_intf.no_map_options
          val partition_mapi :
            ('c,
             ('d,
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
              ('a, 'c) t_ * ('a, 'd) t_)
             Core_kernel.Core_hashtbl_intf.no_map_options)
            Core_kernel.Core_hashtbl_intf.no_map_options
          val partition_tf :
            ('a, 'b) t_ -> f:('-> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'-> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_call :
            ('a, 'b) t_ ->
            'a key_ ->
            if_found:('-> 'c) -> if_not_found:('a key_ -> 'c) -> 'c
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('-> unit) -> unit
          val merge :
            ('c,
             ('k, 'a) t_ ->
             ('k, 'b) t_ ->
             f:(key:'k key_ ->
                [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                'c option) ->
             ('k, 'c) t_)
            Core_kernel.Core_hashtbl_intf.no_map_options
          val merge_into :
            f:(key:'a key_ -> '-> 'c option -> 'c option) ->
            src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('-> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> '-> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('-> '-> bool) -> bool
          val similar :
            ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
            end
          type 'a t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Core_kernel.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
          val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
          val invariant : 'a t -> unit
          val create : ?growth_allowed:bool -> ?size:int -> unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> unit
          val first : 'a t -> 'a option
          val first_with_key : 'a t -> (Key.t * 'a) option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('-> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
        end
      val bin_t : Extended_unix.Mac_address.t Core.Std.Bin_prot.Type_class.t
      val bin_read_t :
        Extended_unix.Mac_address.t Core.Std.Bin_prot.Read.reader
      val __bin_read_t__ :
        (int -> Extended_unix.Mac_address.t) Core.Std.Bin_prot.Read.reader
      val bin_reader_t :
        Extended_unix.Mac_address.t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t :
        Extended_unix.Mac_address.t Core.Std.Bin_prot.Size.sizer
      val bin_write_t :
        Extended_unix.Mac_address.t Core.Std.Bin_prot.Write.writer
      val bin_writer_t :
        Extended_unix.Mac_address.t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> Extended_unix.Mac_address.t
      val sexp_of_t : Extended_unix.Mac_address.t -> Sexplib.Sexp.t
    end
  module Quota :
    sig
      type bytes = private Core.Std.Int63.t
      type inodes = private Core.Std.Int63.t
      val bytes : Core.Std.Int63.t -> Extended_unix.Quota.bytes
      val inodes : Core.Std.Int63.t -> Extended_unix.Quota.inodes
      type 'units limit = {
        soft : 'units option;
        hard : 'units option;
        grace : Core.Std.Time.t option;
      }
      type 'units usage = private 'units
      val query :
        [ `Group | `User ] ->
        id:int ->
        path:string ->
        (Extended_unix.Quota.bytes Extended_unix.Quota.limit *
         Extended_unix.Quota.bytes Extended_unix.Quota.usage *
         Extended_unix.Quota.inodes Extended_unix.Quota.limit *
         Extended_unix.Quota.inodes Extended_unix.Quota.usage)
        Core.Std.Or_error.t
      val set :
        [ `Group | `User ] ->
        id:int ->
        path:string ->
        Extended_unix.Quota.bytes Extended_unix.Quota.limit ->
        Extended_unix.Quota.inodes Extended_unix.Quota.limit ->
        unit Core.Std.Or_error.t
      val bytes_of_sexp : Sexplib.Sexp.t -> Extended_unix.Quota.bytes
      val sexp_of_bytes : Extended_unix.Quota.bytes -> Sexplib.Sexp.t
      val inodes_of_sexp : Sexplib.Sexp.t -> Extended_unix.Quota.inodes
      val sexp_of_inodes : Extended_unix.Quota.inodes -> Sexplib.Sexp.t
      val limit_of_sexp :
        (Sexplib.Sexp.t -> 'units) ->
        Sexplib.Sexp.t -> 'units Extended_unix.Quota.limit
      val sexp_of_limit :
        ('units -> Sexplib.Sexp.t) ->
        'units Extended_unix.Quota.limit -> Sexplib.Sexp.t
    end
  module Mount_entry :
    sig
      type t
      val parse_line :
        string -> Extended_unix.Mount_entry.t option Core.Std.Or_error.t
      val fsname : Extended_unix.Mount_entry.t -> string
      val directory : Extended_unix.Mount_entry.t -> string
      val fstype : Extended_unix.Mount_entry.t -> string
      val options : Extended_unix.Mount_entry.t -> string
      val dump_freq : Extended_unix.Mount_entry.t -> int option
      val fsck_pass : Extended_unix.Mount_entry.t -> int option
      val visible_filesystem :
        Extended_unix.Mount_entry.t list ->
        Extended_unix.Mount_entry.t Core.Std.String.Map.t
      val t_of_sexp : Sexplib.Sexp.t -> Extended_unix.Mount_entry.t
      val sexp_of_t : Extended_unix.Mount_entry.t -> Sexplib.Sexp.t
    end
  val terminal_width : int Core.Std.Lazy.t
  val bin_statvfs : Extended_unix.statvfs Core.Std.Bin_prot.Type_class.t
  val bin_read_statvfs : Extended_unix.statvfs Core.Std.Bin_prot.Read.reader
  val __bin_read_statvfs__ :
    (int -> Extended_unix.statvfs) Core.Std.Bin_prot.Read.reader
  val bin_reader_statvfs :
    Extended_unix.statvfs Core.Std.Bin_prot.Type_class.reader
  val bin_size_statvfs : Extended_unix.statvfs Core.Std.Bin_prot.Size.sizer
  val bin_write_statvfs :
    Extended_unix.statvfs Core.Std.Bin_prot.Write.writer
  val bin_writer_statvfs :
    Extended_unix.statvfs Core.Std.Bin_prot.Type_class.writer
  val statvfs_of_sexp : Sexplib.Sexp.t -> Extended_unix.statvfs
  val sexp_of_statvfs : Extended_unix.statvfs -> Sexplib.Sexp.t
end