sig
  module File_descr :
    sig
      type t = Unix.file_descr
      module Hashable : sig type t = t end
      val hash : t -> int
      val compare : t -> t -> int
      val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.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_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('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_,
             ('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_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             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_,
             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_exn :
            ('a key_, get_key:('-> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             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 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_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 : ('a, 'b) t_ -> f:('-> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'-> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('-> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'-> 'c option) -> ('a, 'c) t_
          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 :
            ('a, 'b) t_ ->
            f:('-> [ `Fst of '| `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          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_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('-> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> '-> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) 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 Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_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_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('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_,
             ('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_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             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_,
             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_exn :
            ('a key_, get_key:('-> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             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 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_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 : ('a, 'b) t_ -> f:('-> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'-> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('-> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'-> 'c option) -> ('a, 'c) t_
          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 :
            ('a, 'b) t_ ->
            f:('-> [ `Fst of '| `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          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_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('-> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> '-> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) 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 compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'Unix.File_descr.Hash_queue.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 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 invariant : 'a t -> unit
          val create : 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 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
        end
      val of_string : string -> t
      val to_string : t -> string
      val of_int : int -> t
      val to_int : t -> int
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  type error =
    Unix.error =
      E2BIG
    | EACCES
    | EAGAIN
    | EBADF
    | EBUSY
    | ECHILD
    | EDEADLK
    | EDOM
    | EEXIST
    | EFAULT
    | EFBIG
    | EINTR
    | EINVAL
    | EIO
    | EISDIR
    | EMFILE
    | EMLINK
    | ENAMETOOLONG
    | ENFILE
    | ENODEV
    | ENOENT
    | ENOEXEC
    | ENOLCK
    | ENOMEM
    | ENOSPC
    | ENOSYS
    | ENOTDIR
    | ENOTEMPTY
    | ENOTTY
    | ENXIO
    | EPERM
    | EPIPE
    | ERANGE
    | EROFS
    | ESPIPE
    | ESRCH
    | EXDEV
    | EWOULDBLOCK
    | EINPROGRESS
    | EALREADY
    | ENOTSOCK
    | EDESTADDRREQ
    | EMSGSIZE
    | EPROTOTYPE
    | ENOPROTOOPT
    | EPROTONOSUPPORT
    | ESOCKTNOSUPPORT
    | EOPNOTSUPP
    | EPFNOSUPPORT
    | EAFNOSUPPORT
    | EADDRINUSE
    | EADDRNOTAVAIL
    | ENETDOWN
    | ENETUNREACH
    | ENETRESET
    | ECONNABORTED
    | ECONNRESET
    | ENOBUFS
    | EISCONN
    | ENOTCONN
    | ESHUTDOWN
    | ETOOMANYREFS
    | ETIMEDOUT
    | ECONNREFUSED
    | EHOSTDOWN
    | EHOSTUNREACH
    | ELOOP
    | EOVERFLOW
    | EUNKNOWNERR of int
  module Error : sig type t = error val of_system_int : int -> t end
  exception Unix_error of error * string * string
  external unix_error : int -> string -> string -> 'a = "unix_error_stub"
  val error_message : error -> string
  val handle_unix_error : (unit -> 'a) -> 'a
  val retry_until_no_eintr : (unit -> 'a) -> 'a
  val environment : unit -> string array
  val putenv : key:string -> data:string -> unit
  val unsetenv : string -> unit
  module Exit :
    sig
      type error = [ `Exit_non_zero of int ]
      type t = (unit, error) Core_kernel.Std.Result.t
      val to_string_hum : t -> string
      val code : t -> int
      val of_code : int -> t
      val or_error : t -> unit Core_kernel.Std.Or_error.t
      val error_of_sexp : Sexplib.Sexp.t -> error
      val __error_of_sexp__ : Sexplib.Sexp.t -> error
      val sexp_of_error : error -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Exit_or_signal :
    sig
      type error = [ `Exit_non_zero of int | `Signal of Signal.t ]
      type t = (unit, error) Core_kernel.Std.Result.t
      val of_unix : Unix.process_status -> t
      val to_string_hum : t -> string
      val or_error : t -> unit Core_kernel.Std.Or_error.t
      val error_of_sexp : Sexplib.Sexp.t -> error
      val __error_of_sexp__ : Sexplib.Sexp.t -> error
      val sexp_of_error : error -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Exit_or_signal_or_stop :
    sig
      type error =
          [ `Exit_non_zero of int | `Signal of Signal.t | `Stop of Signal.t ]
      type t = (unit, error) Core_kernel.Std.Result.t
      val of_unix : Unix.process_status -> t
      val to_string_hum : t -> string
      val or_error : t -> unit Core_kernel.Std.Or_error.t
      val error_of_sexp : Sexplib.Sexp.t -> error
      val __error_of_sexp__ : Sexplib.Sexp.t -> error
      val sexp_of_error : error -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  val exec :
    prog:string ->
    args:string list ->
    ?use_path:bool ->
    ?env:string list -> unit -> Core_kernel.Std.never_returns
  val fork_exec :
    prog:string ->
    args:string list ->
    ?use_path:bool -> ?env:string list -> unit -> Core_kernel.Std.Pid.t
  val fork :
    unit -> [ `In_the_child | `In_the_parent of Core_kernel.Std.Pid.t ]
  type wait_on =
      [ `Any
      | `Group of Core_kernel.Std.Pid.t
      | `My_group
      | `Pid of Core_kernel.Std.Pid.t ]
  val wait :
    ?restart:bool -> wait_on -> Core_kernel.Std.Pid.t * Exit_or_signal.t
  val wait_nohang :
    wait_on -> (Core_kernel.Std.Pid.t * Exit_or_signal.t) option
  val wait_untraced :
    ?restart:bool ->
    wait_on -> Core_kernel.Std.Pid.t * Exit_or_signal_or_stop.t
  val wait_nohang_untraced :
    wait_on -> (Core_kernel.Std.Pid.t * Exit_or_signal_or_stop.t) option
  val waitpid : Core_kernel.Std.Pid.t -> Exit_or_signal.t
  val waitpid_exn : Core_kernel.Std.Pid.t -> unit
  val system : string -> Exit_or_signal.t
  val getpid : unit -> Core_kernel.Std.Pid.t
  val getppid : unit -> Core_kernel.Std.Pid.t option
  val getppid_exn : unit -> Core_kernel.Std.Pid.t
  val nice : int -> int
  val stdin : File_descr.t
  val stdout : File_descr.t
  val stderr : File_descr.t
  type open_flag =
    Unix.open_flag =
      O_RDONLY
    | O_WRONLY
    | O_RDWR
    | O_NONBLOCK
    | O_APPEND
    | O_CREAT
    | O_TRUNC
    | O_EXCL
    | O_NOCTTY
    | O_DSYNC
    | O_SYNC
    | O_RSYNC
    | O_SHARE_DELETE
    | O_CLOEXEC
  type file_perm = int
  val openfile :
    ?perm:file_perm -> mode:open_flag list -> string -> File_descr.t
  module Open_flags :
    sig
      type t = Unix.Open_flags.t
      val of_int : int -> t
      val to_int_exn : t -> int
      val equal : t -> t -> bool
      val empty : t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val intersect : t -> t -> t
      val complement : t -> t
      val is_empty : t -> bool
      val do_intersect : t -> t -> bool
      val are_disjoint : t -> t -> bool
      val rdonly : t
      val wronly : t
      val rdwr : t
      val creat : t
      val excl : t
      val noctty : t
      val trunc : t
      val append : t
      val nonblock : t
      val dsync : t
      val sync : t
      val rsync : t
      val can_read : t -> bool
      val can_write : t -> bool
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  val fcntl_getfl : File_descr.t -> Open_flags.t
  val fcntl_setfl : File_descr.t -> Open_flags.t -> unit
  val close : ?restart:bool -> File_descr.t -> unit
  val with_file :
    ?perm:file_perm ->
    string -> mode:open_flag list -> f:(File_descr.t -> 'a) -> 'a
  val read :
    ?restart:bool ->
    ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int
  val write : ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int
  val single_write :
    ?restart:bool ->
    ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int
  val in_channel_of_descr : File_descr.t -> Core_kernel.Std.In_channel.t
  val out_channel_of_descr : File_descr.t -> Core_kernel.Std.Out_channel.t
  val descr_of_in_channel : Core_kernel.Std.In_channel.t -> File_descr.t
  val descr_of_out_channel : Core_kernel.Std.Out_channel.t -> File_descr.t
  type seek_command = Unix.seek_command = SEEK_SET | SEEK_CUR | SEEK_END
  val lseek : File_descr.t -> int64 -> mode:seek_command -> int64
  val truncate : string -> len:int64 -> unit
  val ftruncate : File_descr.t -> len:int64 -> unit
  type file_kind =
    Unix.file_kind =
      S_REG
    | S_DIR
    | S_CHR
    | S_BLK
    | S_LNK
    | S_FIFO
    | S_SOCK
  type stats =
    Unix.LargeFile.stats = {
    st_dev : int;
    st_ino : int;
    st_kind : file_kind;
    st_perm : file_perm;
    st_nlink : int;
    st_uid : int;
    st_gid : int;
    st_rdev : int;
    st_size : int64;
    st_atime : float;
    st_mtime : float;
    st_ctime : float;
  }
  val stat : string -> stats
  val lstat : string -> stats
  val fstat : File_descr.t -> stats
  module Native_file :
    sig
      type stats =
        Unix.stats = {
        st_dev : int;
        st_ino : int;
        st_kind : file_kind;
        st_perm : file_perm;
        st_nlink : int;
        st_uid : int;
        st_gid : int;
        st_rdev : int;
        st_size : int;
        st_atime : float;
        st_mtime : float;
        st_ctime : float;
      }
      val stat : string -> stats
      val lstat : string -> stats
      val fstat : File_descr.t -> stats
      val lseek : File_descr.t -> int -> mode:seek_command -> int
      val truncate : string -> len:int -> unit
      val ftruncate : File_descr.t -> len:int -> unit
      val stats_of_sexp : Sexplib.Sexp.t -> stats
      val sexp_of_stats : stats -> Sexplib.Sexp.t
    end
  type lock_command =
    Unix.lock_command =
      F_ULOCK
    | F_LOCK
    | F_TLOCK
    | F_TEST
    | F_RLOCK
    | F_TRLOCK
  val lockf :
    File_descr.t -> mode:lock_command -> len:Core_kernel.Std.Int64.t -> unit
  module Flock_command :
    sig
      type t = Unix.Flock_command.t
      val lock_shared : t
      val lock_exclusive : t
      val unlock : t
    end
  val flock : File_descr.t -> Flock_command.t -> bool
  val isatty : File_descr.t -> bool
  val unlink : string -> unit
  val remove : string -> unit
  val rename : src:string -> dst:string -> unit
  val link : ?force:bool -> target:string -> link_name:string -> unit -> unit
  val chmod : string -> perm:file_perm -> unit
  val fchmod : File_descr.t -> perm:file_perm -> unit
  val chown : string -> uid:int -> gid:int -> unit
  val fchown : File_descr.t -> uid:int -> gid:int -> unit
  val umask : int -> int
  val access :
    string ->
    [ `Exec | `Exists | `Read | `Write ] list ->
    (unit, exn) Core_kernel.Std.Result.t
  val access_exn :
    string -> [ `Exec | `Exists | `Read | `Write ] list -> unit
  val dup : File_descr.t -> File_descr.t
  val dup2 : src:File_descr.t -> dst:File_descr.t -> unit
  val set_nonblock : File_descr.t -> unit
  val clear_nonblock : File_descr.t -> unit
  val set_close_on_exec : File_descr.t -> unit
  val clear_close_on_exec : File_descr.t -> unit
  val mkdir : ?perm:file_perm -> string -> unit
  val mkdir_p : ?perm:file_perm -> string -> unit
  val rmdir : string -> unit
  val chdir : string -> unit
  val getcwd : unit -> string
  val chroot : string -> unit
  type dir_handle = Unix.dir_handle
  val opendir : ?restart:bool -> string -> dir_handle
  val readdir : dir_handle -> string
  val rewinddir : dir_handle -> unit
  val closedir : dir_handle -> unit
  val pipe : unit -> File_descr.t * File_descr.t
  val mkfifo : string -> perm:file_perm -> unit
  module Process_info :
    sig
      type t =
        Unix.Process_info.t = {
        pid : Core_kernel.Std.Pid.t;
        stdin : File_descr.t;
        stdout : File_descr.t;
        stderr : File_descr.t;
      }
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  val create_process : prog:string -> args:string list -> Process_info.t
  type env =
      [ `Extend of (string * string) list
      | `Replace of (string * string) list ]
  val create_process_env :
    ?working_dir:string ->
    prog:string -> args:string list -> env:env -> unit -> Process_info.t
  val open_process_in : string -> in_channel
  val open_process_out : string -> out_channel
  val open_process : string -> in_channel * out_channel
  module Process_channels :
    sig
      type t =
        Unix.Process_channels.t = {
        stdin : out_channel;
        stdout : in_channel;
        stderr : in_channel;
      }
    end
  val open_process_full : string -> env:string array -> Process_channels.t
  val close_process_in : in_channel -> Exit_or_signal.t
  val close_process_out : out_channel -> Exit_or_signal.t
  val close_process : in_channel * out_channel -> Exit_or_signal.t
  val close_process_full : Process_channels.t -> Exit_or_signal.t
  val symlink : src:string -> dst:string -> unit
  val readlink : string -> string
  module Select_fds :
    sig
      type t =
        Unix.Select_fds.t = {
        read : File_descr.t list;
        write : File_descr.t list;
        except : File_descr.t list;
      }
      val empty : t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  type select_timeout = [ `After of float | `Immediately | `Never ]
  val select :
    ?restart:bool ->
    read:File_descr.t list ->
    write:File_descr.t list ->
    except:File_descr.t list ->
    timeout:select_timeout -> unit -> Select_fds.t
  val pause : unit -> unit
  type process_times =
    Unix.process_times = {
    tms_utime : float;
    tms_stime : float;
    tms_cutime : float;
    tms_cstime : float;
  }
  type tm =
    Unix.tm = {
    tm_sec : int;
    tm_min : int;
    tm_hour : int;
    tm_mday : int;
    tm_mon : int;
    tm_year : int;
    tm_wday : int;
    tm_yday : int;
    tm_isdst : bool;
  }
  val time : unit -> float
  val gettimeofday : unit -> float
  val gmtime : float -> tm
  val timegm : tm -> float
  val localtime : float -> tm
  val mktime : tm -> float * tm
  val strftime : tm -> string -> string
  val strptime : fmt:string -> string -> Unix.tm
  val alarm : int -> int
  val sleep : int -> unit
  val nanosleep : float -> float
  val times : unit -> process_times
  val utimes : string -> access:float -> modif:float -> unit
  type interval_timer =
    Unix.interval_timer =
      ITIMER_REAL
    | ITIMER_VIRTUAL
    | ITIMER_PROF
  type interval_timer_status =
    Unix.interval_timer_status = {
    it_interval : float;
    it_value : float;
  }
  val getitimer : interval_timer -> interval_timer_status
  val setitimer :
    interval_timer -> interval_timer_status -> interval_timer_status
  val getuid : unit -> int
  val geteuid : unit -> int
  val setuid : int -> unit
  val getgid : unit -> int
  val getegid : unit -> int
  val setgid : int -> unit
  module Passwd :
    sig
      type t =
        Unix.Passwd.t = {
        name : string;
        passwd : string;
        uid : int;
        gid : int;
        gecos : string;
        dir : string;
        shell : string;
      }
      val getbyname : string -> t option
      val getbyname_exn : string -> t
      val getbyuid : int -> t option
      val getbyuid_exn : int -> t
      val getpwents : unit -> t list
      module Low_level :
        sig
          val setpwent : unit -> unit
          val getpwent : unit -> t option
          val getpwent_exn : unit -> t
          val endpwent : unit -> unit
        end
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Group :
    sig
      type t =
        Unix.Group.t = {
        name : string;
        passwd : string;
        gid : int;
        mem : string array;
      }
      val getbyname : string -> t option
      val getbyname_exn : string -> t
      val getbygid : int -> t option
      val getbygid_exn : int -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  val getlogin : unit -> string
  module Protocol_family :
    sig
      type t = [ `Inet | `Inet6 | `Unix ]
      val t_of_sexp : Sexplib.Sexp.t -> t
      val __t_of_sexp__ : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Inet_addr :
    sig
      type t = Unix.inet_addr
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val _squelch_unused_module_warning_ : unit
        end
      type comparator = Unix.Inet_addr.comparator
      val comparator : (t, comparator) Core_kernel.Comparator.t
      val validate_lbound :
        min:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_ubound :
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_bound :
        min:t Core_kernel.Comparable_intf.bound ->
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_tree : 'a t -> 'a t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist : 'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t * [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
                list
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array :
            (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_tree : 'Tree.t -> 'a t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist : 'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> string) ->
            'Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t * [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
            list
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) Core_kernel.Core_set.Tree.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * bool * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
            end
          type t = (Elt.t, Elt.comparator) Core_kernel.Core_set.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * bool * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
        end
      val of_string : string -> t
      val of_string_or_getbyname : string -> t
      val to_string : t -> string
      val bind_any : t
      val bind_any_inet6 : t
      val localhost : t
      val localhost_inet6 : t
      val inet4_addr_of_int32 : Core_kernel.Std.Int32.t -> t
      val inet4_addr_to_int32_exn : t -> Core_kernel.Std.Int32.t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  module Cidr :
    sig
      type t = Unix.Cidr.t
      val of_string : string -> t
      val to_string : t -> string
      val base_address : t -> Inet_addr.t
      val bits : t -> int
      val multicast : t
      val does_match : t -> Inet_addr.t -> bool
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  type socket_domain = Unix.socket_domain = PF_UNIX | PF_INET | PF_INET6
  type socket_type =
    Unix.socket_type =
      SOCK_STREAM
    | SOCK_DGRAM
    | SOCK_RAW
    | SOCK_SEQPACKET
  type sockaddr =
    Unix.sockaddr =
      ADDR_UNIX of string
    | ADDR_INET of Inet_addr.t * int
  val domain_of_sockaddr : sockaddr -> socket_domain
  val socket :
    domain:socket_domain -> kind:socket_type -> protocol:int -> File_descr.t
  val socketpair :
    domain:socket_domain ->
    kind:socket_type -> protocol:int -> File_descr.t * File_descr.t
  val accept : File_descr.t -> File_descr.t * sockaddr
  val bind : File_descr.t -> addr:sockaddr -> unit
  val connect : File_descr.t -> addr:sockaddr -> unit
  val listen : File_descr.t -> max:int -> unit
  type shutdown_command =
    Unix.shutdown_command =
      SHUTDOWN_RECEIVE
    | SHUTDOWN_SEND
    | SHUTDOWN_ALL
  val shutdown : File_descr.t -> mode:shutdown_command -> unit
  val getsockname : File_descr.t -> sockaddr
  val getpeername : File_descr.t -> sockaddr
  type msg_flag = Unix.msg_flag = MSG_OOB | MSG_DONTROUTE | MSG_PEEK
  val recv :
    File_descr.t ->
    buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
  val recvfrom :
    File_descr.t ->
    buf:string -> pos:int -> len:int -> mode:msg_flag list -> int * sockaddr
  val send :
    File_descr.t ->
    buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
  val sendto :
    File_descr.t ->
    buf:string ->
    pos:int -> len:int -> mode:msg_flag list -> addr:sockaddr -> int
  type socket_bool_option =
    Unix.socket_bool_option =
      SO_DEBUG
    | SO_BROADCAST
    | SO_REUSEADDR
    | SO_KEEPALIVE
    | SO_DONTROUTE
    | SO_OOBINLINE
    | SO_ACCEPTCONN
    | TCP_NODELAY
    | IPV6_ONLY
  type socket_int_option =
    Unix.socket_int_option =
      SO_SNDBUF
    | SO_RCVBUF
    | SO_ERROR
    | SO_TYPE
    | SO_RCVLOWAT
    | SO_SNDLOWAT
  type socket_optint_option = Unix.socket_optint_option = SO_LINGER
  type socket_float_option =
    Unix.socket_float_option =
      SO_RCVTIMEO
    | SO_SNDTIMEO
  val getsockopt : File_descr.t -> socket_bool_option -> bool
  val setsockopt : File_descr.t -> socket_bool_option -> bool -> unit
  val getsockopt_int : File_descr.t -> socket_int_option -> int
  val setsockopt_int : File_descr.t -> socket_int_option -> int -> unit
  val getsockopt_optint : File_descr.t -> socket_optint_option -> int option
  val setsockopt_optint :
    File_descr.t -> socket_optint_option -> int option -> unit
  val getsockopt_float : File_descr.t -> socket_float_option -> float
  val setsockopt_float : File_descr.t -> socket_float_option -> float -> unit
  val open_connection : sockaddr -> in_channel * out_channel
  val shutdown_connection : in_channel -> unit
  val establish_server :
    (in_channel -> out_channel -> unit) -> addr:sockaddr -> unit
  val gethostname : unit -> string
  module Host :
    sig
      type t =
        Unix.Host.t = {
        name : string;
        aliases : string array;
        family : Protocol_family.t;
        addresses : Inet_addr.t array;
      }
      val getbyname : string -> t option
      val getbyname_exn : string -> t
      val getbyaddr : Inet_addr.t -> t option
      val getbyaddr_exn : Inet_addr.t -> t
      val have_address_in_common : t -> t -> bool
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Protocol :
    sig
      type t =
        Unix.Protocol.t = {
        name : string;
        aliases : string array;
        proto : int;
      }
      val getbyname : string -> t option
      val getbyname_exn : string -> t
      val getbynumber : int -> t option
      val getbynumber_exn : int -> t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Service :
    sig
      type t =
        Unix.Service.t = {
        name : string;
        aliases : string array;
        port : int;
        proto : string;
      }
      val getbyname : string -> protocol:string -> t option
      val getbyname_exn : string -> protocol:string -> t
      val getbyport : int -> protocol:string -> t option
      val getbyport_exn : int -> protocol:string -> t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  type addr_info =
    Unix.addr_info = {
    ai_family : socket_domain;
    ai_socktype : socket_type;
    ai_protocol : int;
    ai_addr : sockaddr;
    ai_canonname : string;
  }
  type getaddrinfo_option =
    Unix.getaddrinfo_option =
      AI_FAMILY of socket_domain
    | AI_SOCKTYPE of socket_type
    | AI_PROTOCOL of int
    | AI_NUMERICHOST
    | AI_CANONNAME
    | AI_PASSIVE
  val getaddrinfo :
    string -> string -> getaddrinfo_option list -> addr_info list
  type name_info =
    Unix.name_info = {
    ni_hostname : string;
    ni_service : string;
  }
  type getnameinfo_option =
    Unix.getnameinfo_option =
      NI_NOFQDN
    | NI_NUMERICHOST
    | NI_NAMEREQD
    | NI_NUMERICSERV
    | NI_DGRAM
  val getnameinfo : sockaddr -> getnameinfo_option list -> name_info
  module Terminal_io :
    sig
      type t =
        Unix.terminal_io = {
        mutable c_ignbrk : bool;
        mutable c_brkint : bool;
        mutable c_ignpar : bool;
        mutable c_parmrk : bool;
        mutable c_inpck : bool;
        mutable c_istrip : bool;
        mutable c_inlcr : bool;
        mutable c_igncr : bool;
        mutable c_icrnl : bool;
        mutable c_ixon : bool;
        mutable c_ixoff : bool;
        mutable c_opost : bool;
        mutable c_obaud : int;
        mutable c_ibaud : int;
        mutable c_csize : int;
        mutable c_cstopb : int;
        mutable c_cread : bool;
        mutable c_parenb : bool;
        mutable c_parodd : bool;
        mutable c_hupcl : bool;
        mutable c_clocal : bool;
        mutable c_isig : bool;
        mutable c_icanon : bool;
        mutable c_noflsh : bool;
        mutable c_echo : bool;
        mutable c_echoe : bool;
        mutable c_echok : bool;
        mutable c_echonl : bool;
        mutable c_vintr : char;
        mutable c_vquit : char;
        mutable c_verase : char;
        mutable c_vkill : char;
        mutable c_veof : char;
        mutable c_veol : char;
        mutable c_vmin : int;
        mutable c_vtime : int;
        mutable c_vstart : char;
        mutable c_vstop : char;
      }
      type setattr_when = Unix.setattr_when = TCSANOW | TCSADRAIN | TCSAFLUSH
      val tcgetattr : File_descr.t -> t
      val tcsetattr : t -> File_descr.t -> mode:setattr_when -> unit
      val tcsendbreak : File_descr.t -> duration:int -> unit
      val tcdrain : File_descr.t -> unit
      type flush_queue = Unix.flush_queue = TCIFLUSH | TCOFLUSH | TCIOFLUSH
      val tcflush : File_descr.t -> mode:flush_queue -> unit
      type flow_action = Unix.flow_action = TCOOFF | TCOON | TCIOFF | TCION
      val tcflow : File_descr.t -> mode:flow_action -> unit
      val setsid : unit -> int
      val sexp_of_t : t -> Sexplib.Sexp.t
      val sexp_of_setattr_when : setattr_when -> Sexplib.Sexp.t
      val flush_queue_of_sexp : Sexplib.Sexp.t -> flush_queue
      val sexp_of_flush_queue : flush_queue -> Sexplib.Sexp.t
      val flow_action_of_sexp : Sexplib.Sexp.t -> flow_action
      val sexp_of_flow_action : flow_action -> Sexplib.Sexp.t
    end
  val get_sockaddr : string -> int -> sockaddr
  val set_in_channel_timeout : in_channel -> float -> unit
  val set_out_channel_timeout : out_channel -> float -> unit
  val exit_immediately : int -> 'a
  val mknod :
    ?file_kind:file_kind ->
    ?perm:int -> ?major:int -> ?minor:int -> string -> unit
  module IOVec :
    sig
      type 'buf t =
        'buf Unix.IOVec.t = private {
        buf : 'buf;
        pos : int;
        len : int;
      }
      type 'buf kind = 'buf Unix.IOVec.kind
      type bigstring =
          (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout)
          Bigarray.Array1.t
      val string_kind : string kind
      val bigstring_kind : bigstring kind
      val empty : 'buf kind -> 'buf t
      val of_string : ?pos:int -> ?len:int -> string -> string t
      val of_bigstring : ?pos:int -> ?len:int -> bigstring -> bigstring t
      val drop : 'buf t -> int -> 'buf t
      val max_iovecs : int
      val t_of_sexp : (Sexplib.Sexp.t -> 'buf) -> Sexplib.Sexp.t -> 'buf t
      val sexp_of_t : ('buf -> Sexplib.Sexp.t) -> 'buf t -> Sexplib.Sexp.t
    end
  external dirfd : dir_handle -> File_descr.t = "unix_dirfd"
  external sync : unit -> unit = "unix_sync"
  external fsync : File_descr.t -> unit = "unix_fsync"
  external fdatasync : File_descr.t -> unit = "unix_fdatasync"
  external readdir_ino : dir_handle -> string * nativeint
    = "unix_readdir_ino_stub"
  val read_assume_fd_is_nonblocking :
    File_descr.t -> ?pos:int -> ?len:int -> string -> int
  val write_assume_fd_is_nonblocking :
    File_descr.t -> ?pos:int -> ?len:int -> string -> int
  val writev_assume_fd_is_nonblocking :
    File_descr.t -> ?count:int -> string IOVec.t array -> int
  val writev : File_descr.t -> ?count:int -> string IOVec.t array -> int
  external pselect :
    File_descr.t list ->
    File_descr.t list ->
    File_descr.t list ->
    float ->
    int list -> File_descr.t list * File_descr.t list * File_descr.t list
    = "unix_pselect_stub"
  module RLimit :
    sig
      type limit = Unix.RLimit.limit = Limit of int64 | Infinity
      type t = Unix.RLimit.t = { cur : limit; max : limit; }
      type resource = Unix.RLimit.resource
      val core_file_size : resource
      val cpu_seconds : resource
      val data_segment : resource
      val file_size : resource
      val num_file_descriptors : resource
      val stack : resource
      val virtual_memory : resource
      val nice : resource Core_kernel.Std.Or_error.t
      val get : resource -> t
      val set : resource -> t -> unit
      val limit_of_sexp : Sexplib.Sexp.t -> limit
      val sexp_of_limit : limit -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val resource_of_sexp : Sexplib.Sexp.t -> resource
      val sexp_of_resource : resource -> Sexplib.Sexp.t
    end
  module Resource_usage :
    sig
      type t =
        Unix.Resource_usage.t = {
        utime : float;
        stime : float;
        maxrss : int64;
        ixrss : int64;
        idrss : int64;
        isrss : int64;
        minflt : int64;
        majflt : int64;
        nswap : int64;
        inblock : int64;
        oublock : int64;
        msgsnd : int64;
        msgrcv : int64;
        nsignals : int64;
        nvcsw : int64;
        nivcsw : int64;
      }
      val nivcsw : t -> int64
      val nvcsw : t -> int64
      val nsignals : t -> int64
      val msgrcv : t -> int64
      val msgsnd : t -> int64
      val oublock : t -> int64
      val inblock : t -> int64
      val nswap : t -> int64
      val majflt : t -> int64
      val minflt : t -> int64
      val isrss : t -> int64
      val idrss : t -> int64
      val ixrss : t -> int64
      val maxrss : t -> int64
      val stime : t -> float
      val utime : t -> float
      module Fields :
        sig
          val names : string list
          val nivcsw : (t, int64) Fieldslib.Field.t
          val nvcsw : (t, int64) Fieldslib.Field.t
          val nsignals : (t, int64) Fieldslib.Field.t
          val msgrcv : (t, int64) Fieldslib.Field.t
          val msgsnd : (t, int64) Fieldslib.Field.t
          val oublock : (t, int64) Fieldslib.Field.t
          val inblock : (t, int64) Fieldslib.Field.t
          val nswap : (t, int64) Fieldslib.Field.t
          val majflt : (t, int64) Fieldslib.Field.t
          val minflt : (t, int64) Fieldslib.Field.t
          val isrss : (t, int64) Fieldslib.Field.t
          val idrss : (t, int64) Fieldslib.Field.t
          val ixrss : (t, int64) Fieldslib.Field.t
          val maxrss : (t, int64) Fieldslib.Field.t
          val stime : (t, float) Fieldslib.Field.t
          val utime : (t, float) Fieldslib.Field.t
          val fold :
            init:'acc__ ->
            utime:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
            stime:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
            maxrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            ixrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            idrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            isrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            minflt:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            majflt:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            nswap:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            inblock:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            oublock:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            msgsnd:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            msgrcv:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            nsignals:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            nvcsw:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            nivcsw:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
            'acc__
          val make_creator :
            utime:((t, float) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> float) * 'compile_acc__) ->
            stime:((t, float) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> float) * 'compile_acc__) ->
            maxrss:((t, int64) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            ixrss:((t, int64) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            idrss:((t, int64) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            isrss:((t, int64) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            minflt:((t, int64) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            majflt:((t, int64) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            nswap:((t, int64) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            inblock:((t, int64) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            oublock:((t, int64) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            msgsnd:((t, int64) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            msgrcv:((t, int64) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            nsignals:((t, int64) Fieldslib.Field.t ->
                      'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            nvcsw:((t, int64) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            nivcsw:((t, int64) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
            'compile_acc__ -> ('input__ -> t) * 'compile_acc__
          val create :
            utime:float ->
            stime:float ->
            maxrss:int64 ->
            ixrss:int64 ->
            idrss:int64 ->
            isrss:int64 ->
            minflt:int64 ->
            majflt:int64 ->
            nswap:int64 ->
            inblock:int64 ->
            oublock:int64 ->
            msgsnd:int64 ->
            msgrcv:int64 ->
            nsignals:int64 -> nvcsw:int64 -> nivcsw:int64 -> t
          val map :
            utime:((t, float) Fieldslib.Field.t -> float) ->
            stime:((t, float) Fieldslib.Field.t -> float) ->
            maxrss:((t, int64) Fieldslib.Field.t -> int64) ->
            ixrss:((t, int64) Fieldslib.Field.t -> int64) ->
            idrss:((t, int64) Fieldslib.Field.t -> int64) ->
            isrss:((t, int64) Fieldslib.Field.t -> int64) ->
            minflt:((t, int64) Fieldslib.Field.t -> int64) ->
            majflt:((t, int64) Fieldslib.Field.t -> int64) ->
            nswap:((t, int64) Fieldslib.Field.t -> int64) ->
            inblock:((t, int64) Fieldslib.Field.t -> int64) ->
            oublock:((t, int64) Fieldslib.Field.t -> int64) ->
            msgsnd:((t, int64) Fieldslib.Field.t -> int64) ->
            msgrcv:((t, int64) Fieldslib.Field.t -> int64) ->
            nsignals:((t, int64) Fieldslib.Field.t -> int64) ->
            nvcsw:((t, int64) Fieldslib.Field.t -> int64) ->
            nivcsw:((t, int64) Fieldslib.Field.t -> int64) -> t
          val iter :
            utime:((t, float) Fieldslib.Field.t -> unit) ->
            stime:((t, float) Fieldslib.Field.t -> unit) ->
            maxrss:((t, int64) Fieldslib.Field.t -> unit) ->
            ixrss:((t, int64) Fieldslib.Field.t -> unit) ->
            idrss:((t, int64) Fieldslib.Field.t -> unit) ->
            isrss:((t, int64) Fieldslib.Field.t -> unit) ->
            minflt:((t, int64) Fieldslib.Field.t -> unit) ->
            majflt:((t, int64) Fieldslib.Field.t -> unit) ->
            nswap:((t, int64) Fieldslib.Field.t -> unit) ->
            inblock:((t, int64) Fieldslib.Field.t -> unit) ->
            oublock:((t, int64) Fieldslib.Field.t -> unit) ->
            msgsnd:((t, int64) Fieldslib.Field.t -> unit) ->
            msgrcv:((t, int64) Fieldslib.Field.t -> unit) ->
            nsignals:((t, int64) Fieldslib.Field.t -> unit) ->
            nvcsw:((t, int64) Fieldslib.Field.t -> unit) ->
            nivcsw:((t, int64) Fieldslib.Field.t -> unit) -> unit
          val for_all :
            utime:((t, float) Fieldslib.Field.t -> bool) ->
            stime:((t, float) Fieldslib.Field.t -> bool) ->
            maxrss:((t, int64) Fieldslib.Field.t -> bool) ->
            ixrss:((t, int64) Fieldslib.Field.t -> bool) ->
            idrss:((t, int64) Fieldslib.Field.t -> bool) ->
            isrss:((t, int64) Fieldslib.Field.t -> bool) ->
            minflt:((t, int64) Fieldslib.Field.t -> bool) ->
            majflt:((t, int64) Fieldslib.Field.t -> bool) ->
            nswap:((t, int64) Fieldslib.Field.t -> bool) ->
            inblock:((t, int64) Fieldslib.Field.t -> bool) ->
            oublock:((t, int64) Fieldslib.Field.t -> bool) ->
            msgsnd:((t, int64) Fieldslib.Field.t -> bool) ->
            msgrcv:((t, int64) Fieldslib.Field.t -> bool) ->
            nsignals:((t, int64) Fieldslib.Field.t -> bool) ->
            nvcsw:((t, int64) Fieldslib.Field.t -> bool) ->
            nivcsw:((t, int64) Fieldslib.Field.t -> bool) -> bool
          val exists :
            utime:((t, float) Fieldslib.Field.t -> bool) ->
            stime:((t, float) Fieldslib.Field.t -> bool) ->
            maxrss:((t, int64) Fieldslib.Field.t -> bool) ->
            ixrss:((t, int64) Fieldslib.Field.t -> bool) ->
            idrss:((t, int64) Fieldslib.Field.t -> bool) ->
            isrss:((t, int64) Fieldslib.Field.t -> bool) ->
            minflt:((t, int64) Fieldslib.Field.t -> bool) ->
            majflt:((t, int64) Fieldslib.Field.t -> bool) ->
            nswap:((t, int64) Fieldslib.Field.t -> bool) ->
            inblock:((t, int64) Fieldslib.Field.t -> bool) ->
            oublock:((t, int64) Fieldslib.Field.t -> bool) ->
            msgsnd:((t, int64) Fieldslib.Field.t -> bool) ->
            msgrcv:((t, int64) Fieldslib.Field.t -> bool) ->
            nsignals:((t, int64) Fieldslib.Field.t -> bool) ->
            nvcsw:((t, int64) Fieldslib.Field.t -> bool) ->
            nivcsw:((t, int64) Fieldslib.Field.t -> bool) -> bool
          val to_list :
            utime:((t, float) Fieldslib.Field.t -> 'elem__) ->
            stime:((t, float) Fieldslib.Field.t -> 'elem__) ->
            maxrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            ixrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            idrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            isrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            minflt:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            majflt:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            nswap:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            inblock:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            oublock:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            msgsnd:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            msgrcv:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            nsignals:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            nvcsw:((t, int64) Fieldslib.Field.t -> 'elem__) ->
            nivcsw:((t, int64) Fieldslib.Field.t -> 'elem__) -> 'elem__ list
          val map_poly :
            ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
            'x0 list
          module Direct :
            sig
              val iter :
                t ->
                utime:((t, float) Fieldslib.Field.t -> t -> float -> unit) ->
                stime:((t, float) Fieldslib.Field.t -> t -> float -> unit) ->
                maxrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                ixrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                idrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                isrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                minflt:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                majflt:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                nswap:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                inblock:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                oublock:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                msgsnd:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                msgrcv:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                nsignals:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                nvcsw:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                nivcsw:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
                unit
              val fold :
                t ->
                init:'acc__ ->
                utime:('acc__ ->
                       (t, float) Fieldslib.Field.t -> t -> float -> 'acc__) ->
                stime:('acc__ ->
                       (t, float) Fieldslib.Field.t -> t -> float -> 'acc__) ->
                maxrss:('acc__ ->
                        (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                ixrss:('acc__ ->
                       (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                idrss:('acc__ ->
                       (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                isrss:('acc__ ->
                       (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                minflt:('acc__ ->
                        (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                majflt:('acc__ ->
                        (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                nswap:('acc__ ->
                       (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                inblock:('acc__ ->
                         (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                oublock:('acc__ ->
                         (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                msgsnd:('acc__ ->
                        (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                msgrcv:('acc__ ->
                        (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                nsignals:('acc__ ->
                          (t, int64) Fieldslib.Field.t ->
                          t -> int64 -> 'acc__) ->
                nvcsw:('acc__ ->
                       (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                nivcsw:('acc__ ->
                        (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
                'acc__
            end
        end
      val get : [ `Children | `Self ] -> t
      val add : t -> t -> t
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  type sysconf =
    Unix.sysconf =
      ARG_MAX
    | CHILD_MAX
    | HOST_NAME_MAX
    | LOGIN_NAME_MAX
    | OPEN_MAX
    | PAGESIZE
    | RE_DUP_MAX
    | STREAM_MAX
    | SYMLOOP_MAX
    | TTY_NAME_MAX
    | TZNAME_MAX
    | POSIX_VERSION
    | PHYS_PAGES
    | AVPHYS_PAGES
    | IOV_MAX
  external sysconf : sysconf -> int64 = "unix_sysconf"
  val mkstemp : string -> string * File_descr.t
  val mkdtemp : string -> string
  external abort : unit -> 'a = "unix_abort" "noalloc"
  external initgroups : string -> int -> unit = "unix_initgroups"
  val getgrouplist : string -> int -> int array
  val getgroups : unit -> int array
  val fnmatch :
    ?flags:[ `Casefold
           | `File_name
           | `Leading_dir
           | `No_escape
           | `Pathname
           | `Period ] list ->
    pat:string -> string -> bool
  val wordexp :
    (?flags:[ `No_cmd | `Show_err | `Undef ] list -> string -> string array)
    Core_kernel.Std.Or_error.t
  module Utsname :
    sig
      type t = Unix.Utsname.t
      val sysname : t -> string
      val nodename : t -> string
      val release : t -> string
      val version : t -> string
      val machine : t -> string
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  val uname : unit -> Utsname.t
  val if_indextoname : int -> string
  val mcast_join : ?ifname:string -> File_descr.t -> sockaddr -> unit
  val mcast_leave : ?ifname:string -> File_descr.t -> sockaddr -> unit
  val get_mcast_ttl : File_descr.t -> int
  val set_mcast_ttl : File_descr.t -> int -> unit
  val get_mcast_loop : File_descr.t -> bool
  val set_mcast_loop : File_descr.t -> bool -> unit
  module Scheduler :
    sig
      module Policy :
        sig
          type t = [ `Fifo | `Other | `Round_robin ]
          val t_of_sexp : Sexplib.Sexp.t -> t
          val __t_of_sexp__ : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      val set :
        pid:Core_kernel.Std.Pid.t option ->
        policy:Policy.t -> priority:int -> unit
    end
  module Priority : sig external nice : int -> int = "unix_nice" end
  module Mman :
    sig
      module Mcl_flags :
        sig
          type t = Unix.Mman.Mcl_flags.t = Current | Future
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      val mlockall : Mcl_flags.t list -> unit
      val munlockall : unit -> unit
    end
  val error_of_sexp : Sexplib.Sexp.t -> error
  val sexp_of_error : error -> Sexplib.Sexp.t
  val wait_on_of_sexp : Sexplib.Sexp.t -> wait_on
  val __wait_on_of_sexp__ : Sexplib.Sexp.t -> wait_on
  val sexp_of_wait_on : wait_on -> Sexplib.Sexp.t
  val open_flag_of_sexp : Sexplib.Sexp.t -> open_flag
  val sexp_of_open_flag : open_flag -> Sexplib.Sexp.t
  val file_perm_of_sexp : Sexplib.Sexp.t -> file_perm
  val sexp_of_file_perm : file_perm -> Sexplib.Sexp.t
  val seek_command_of_sexp : Sexplib.Sexp.t -> seek_command
  val sexp_of_seek_command : seek_command -> Sexplib.Sexp.t
  val file_kind_of_sexp : Sexplib.Sexp.t -> file_kind
  val sexp_of_file_kind : file_kind -> Sexplib.Sexp.t
  val stats_of_sexp : Sexplib.Sexp.t -> stats
  val sexp_of_stats : stats -> Sexplib.Sexp.t
  val lock_command_of_sexp : Sexplib.Sexp.t -> lock_command
  val sexp_of_lock_command : lock_command -> Sexplib.Sexp.t
  val env_of_sexp : Sexplib.Sexp.t -> env
  val __env_of_sexp__ : Sexplib.Sexp.t -> env
  val sexp_of_env : env -> Sexplib.Sexp.t
  val sexp_of_select_timeout : select_timeout -> Sexplib.Sexp.t
  val process_times_of_sexp : Sexplib.Sexp.t -> process_times
  val sexp_of_process_times : process_times -> Sexplib.Sexp.t
  val tm_of_sexp : Sexplib.Sexp.t -> tm
  val sexp_of_tm : tm -> Sexplib.Sexp.t
  val interval_timer_of_sexp : Sexplib.Sexp.t -> interval_timer
  val sexp_of_interval_timer : interval_timer -> Sexplib.Sexp.t
  val interval_timer_status_of_sexp : Sexplib.Sexp.t -> interval_timer_status
  val sexp_of_interval_timer_status : interval_timer_status -> Sexplib.Sexp.t
  val bin_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.t
  val bin_read_socket_domain :
    socket_domain Core_kernel.Std.Bin_prot.Read.reader
  val __bin_read_socket_domain__ :
    (int -> socket_domain) Core_kernel.Std.Bin_prot.Read.reader
  val bin_reader_socket_domain :
    socket_domain Core_kernel.Std.Bin_prot.Type_class.reader
  val bin_size_socket_domain :
    socket_domain Core_kernel.Std.Bin_prot.Size.sizer
  val bin_write_socket_domain :
    socket_domain Core_kernel.Std.Bin_prot.Write.writer
  val bin_writer_socket_domain :
    socket_domain Core_kernel.Std.Bin_prot.Type_class.writer
  val socket_domain_of_sexp : Sexplib.Sexp.t -> socket_domain
  val sexp_of_socket_domain : socket_domain -> Sexplib.Sexp.t
  val bin_socket_type : socket_type Core_kernel.Std.Bin_prot.Type_class.t
  val bin_read_socket_type : socket_type Core_kernel.Std.Bin_prot.Read.reader
  val __bin_read_socket_type__ :
    (int -> socket_type) Core_kernel.Std.Bin_prot.Read.reader
  val bin_reader_socket_type :
    socket_type Core_kernel.Std.Bin_prot.Type_class.reader
  val bin_size_socket_type : socket_type Core_kernel.Std.Bin_prot.Size.sizer
  val bin_write_socket_type :
    socket_type Core_kernel.Std.Bin_prot.Write.writer
  val bin_writer_socket_type :
    socket_type Core_kernel.Std.Bin_prot.Type_class.writer
  val socket_type_of_sexp : Sexplib.Sexp.t -> socket_type
  val sexp_of_socket_type : socket_type -> Sexplib.Sexp.t
  val bin_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.t
  val bin_read_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Read.reader
  val __bin_read_sockaddr__ :
    (int -> sockaddr) Core_kernel.Std.Bin_prot.Read.reader
  val bin_reader_sockaddr :
    sockaddr Core_kernel.Std.Bin_prot.Type_class.reader
  val bin_size_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Size.sizer
  val bin_write_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Write.writer
  val bin_writer_sockaddr :
    sockaddr Core_kernel.Std.Bin_prot.Type_class.writer
  val sockaddr_of_sexp : Sexplib.Sexp.t -> sockaddr
  val sexp_of_sockaddr : sockaddr -> Sexplib.Sexp.t
  val shutdown_command_of_sexp : Sexplib.Sexp.t -> shutdown_command
  val sexp_of_shutdown_command : shutdown_command -> Sexplib.Sexp.t
  val msg_flag_of_sexp : Sexplib.Sexp.t -> msg_flag
  val sexp_of_msg_flag : msg_flag -> Sexplib.Sexp.t
  val socket_bool_option_of_sexp : Sexplib.Sexp.t -> socket_bool_option
  val sexp_of_socket_bool_option : socket_bool_option -> Sexplib.Sexp.t
  val socket_int_option_of_sexp : Sexplib.Sexp.t -> socket_int_option
  val sexp_of_socket_int_option : socket_int_option -> Sexplib.Sexp.t
  val socket_float_option_of_sexp : Sexplib.Sexp.t -> socket_float_option
  val sexp_of_socket_float_option : socket_float_option -> Sexplib.Sexp.t
  val addr_info_of_sexp : Sexplib.Sexp.t -> addr_info
  val sexp_of_addr_info : addr_info -> Sexplib.Sexp.t
  val getaddrinfo_option_of_sexp : Sexplib.Sexp.t -> getaddrinfo_option
  val sexp_of_getaddrinfo_option : getaddrinfo_option -> Sexplib.Sexp.t
  val name_info_of_sexp : Sexplib.Sexp.t -> name_info
  val sexp_of_name_info : name_info -> Sexplib.Sexp.t
  val getnameinfo_option_of_sexp : Sexplib.Sexp.t -> getnameinfo_option
  val sexp_of_getnameinfo_option : getnameinfo_option -> Sexplib.Sexp.t
  val sysconf_of_sexp : Sexplib.Sexp.t -> sysconf
  val sexp_of_sysconf : sysconf -> Sexplib.Sexp.t
end