sig
  module Deferred :
    sig
      type 'a t = 'a Async_core.Ivar.Deferred.t
      val create : ('a Async_core.Ivar.t -> unit) -> 'a t
      val upon : 'a t -> ('a -> unit) -> unit
      val peek : 'a t -> 'a option
      val is_determined : 'a t -> bool
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      val bind : 'a t -> ('a -> 'b t) -> 'b t
      val return : 'a -> 'a t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore : 'a t -> unit t
      val all_ignore : unit t list -> unit t
      module Infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
          val ( >>> ) : 'a t -> ('a -> unit) -> unit
        end
      val unit : unit t
      val never : unit -> 'a t
      val both : 'a t -> 'b t -> ('a * 'b) t
      val all : 'a t list -> 'a list t
      val all_unit : unit t list -> unit t
      val any : 'a t list -> 'a t
      val any_unit : 'a t list -> unit t
      module type Monad_sequence =
        sig
          type 'a t
          val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
          val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
          val init :
            ?how:Async_core.Deferred_intf.how ->
            int -> f:(int -> 'a t) -> 'a t t
          val iter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> unit t) -> unit t
          val iteri :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:(int -> 'a -> unit t) -> unit t
          val map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b t) -> 'b t t
          val filter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> bool t) -> 'a t t
          val filter_map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b option t) -> 'b t t
          val find : 'a t -> f:('a -> bool t) -> 'a option t
          val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
          val all : 'a t t -> 'a t t
          val all_unit : unit t t -> unit t
        end
      module Array :
        sig
          type 'a t = 'a array
          val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
          val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
          val init :
            ?how:Async_core.Deferred_intf.how ->
            int -> f:(int -> 'a t) -> 'a t t
          val iter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> unit t) -> unit t
          val iteri :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:(int -> 'a -> unit t) -> unit t
          val map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b t) -> 'b t t
          val filter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> bool t) -> 'a t t
          val filter_map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b option t) -> 'b t t
          val find : 'a t -> f:('a -> bool t) -> 'a option t
          val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
          val all : 'a t t -> 'a t t
          val all_unit : unit t t -> unit t
        end
      module List :
        sig
          type 'a t = 'a list
          val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
          val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
          val init :
            ?how:Async_core.Deferred_intf.how ->
            int -> f:(int -> 'a t) -> 'a t t
          val iter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> unit t) -> unit t
          val iteri :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:(int -> 'a -> unit t) -> unit t
          val map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b t) -> 'b t t
          val filter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> bool t) -> 'a t t
          val filter_map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b option t) -> 'b t t
          val find : 'a t -> f:('a -> bool t) -> 'a option t
          val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
          val all : 'a t t -> 'a t t
          val all_unit : unit t t -> unit t
        end
      module Queue :
        sig
          type 'a t = 'a Core.Std.Queue.t
          val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
          val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
          val init :
            ?how:Async_core.Deferred_intf.how ->
            int -> f:(int -> 'a t) -> 'a t t
          val iter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> unit t) -> unit t
          val iteri :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:(int -> 'a -> unit t) -> unit t
          val map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b t) -> 'b t t
          val filter :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> bool t) -> 'a t t
          val filter_map :
            ?how:Async_core.Deferred_intf.how ->
            'a t -> f:('a -> 'b option t) -> 'b t t
          val find : 'a t -> f:('a -> bool t) -> 'a option t
          val find_map : 'a t -> f:('a -> 'b option t) -> 'b option t
          val all : 'a t t -> 'a t t
          val all_unit : unit t t -> unit t
        end
      module Map :
        sig
          type ('a, 'b, 'c) t = ('a, 'b, 'c) Core.Std.Map.t
          val change :
            ('k, 'v, 'comparator) t ->
            'k ->
            ('v option -> 'v option Async_core.Deferred_intf.Deferred.t) ->
            ('k, 'v, 'comparator) t Async_core.Deferred_intf.Deferred.t
          val iter :
            ?how:Async_core.Deferred_intf.how ->
            ('k, 'v, 'a) t ->
            f:(key:'k -> data:'v -> unit Async_core.Deferred_intf.Deferred.t) ->
            unit Async_core.Deferred_intf.Deferred.t
          val map :
            ?how:Async_core.Deferred_intf.how ->
            ('k, 'v1, 'comparator) t ->
            f:('v1 -> 'v2 Async_core.Deferred_intf.Deferred.t) ->
            ('k, 'v2, 'comparator) t Async_core.Deferred_intf.Deferred.t
          val mapi :
            ?how:Async_core.Deferred_intf.how ->
            ('k, 'v1, 'comparator) t ->
            f:(key:'k -> data:'v1 -> 'v2 Async_core.Deferred_intf.Deferred.t) ->
            ('k, 'v2, 'comparator) t Async_core.Deferred_intf.Deferred.t
          val fold :
            ('k, 'v, 'b) t ->
            init:'a ->
            f:(key:'k ->
               data:'v -> 'a -> 'a Async_core.Deferred_intf.Deferred.t) ->
            'a Async_core.Deferred_intf.Deferred.t
          val fold_right :
            ('k, 'v, 'b) t ->
            init:'a ->
            f:(key:'k ->
               data:'v -> 'a -> 'a Async_core.Deferred_intf.Deferred.t) ->
            'a Async_core.Deferred_intf.Deferred.t
          val filter :
            ?how:Async_core.Deferred_intf.how ->
            ('k, 'v, 'comparable) t ->
            f:(key:'k -> data:'v -> bool Async_core.Deferred_intf.Deferred.t) ->
            ('k, 'v, 'comparable) t Async_core.Deferred_intf.Deferred.t
          val filter_map :
            ?how:Async_core.Deferred_intf.how ->
            ('k, 'v1, 'comparable) t ->
            f:('v1 -> 'v2 option Async_core.Deferred_intf.Deferred.t) ->
            ('k, 'v2, 'comparable) t Async_core.Deferred_intf.Deferred.t
          val filter_mapi :
            ?how:Async_core.Deferred_intf.how ->
            ('k, 'v1, 'comparable) t ->
            f:(key:'k ->
               data:'v1 -> 'v2 option Async_core.Deferred_intf.Deferred.t) ->
            ('k, 'v2, 'comparable) t Async_core.Deferred_intf.Deferred.t
          val merge :
            ?how:Async_core.Deferred_intf.how ->
            ('k, 'v1, 'comparator) t ->
            ('k, 'v2, 'comparator) t ->
            f:(key:'k ->
               [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
               'v3 option Async_core.Deferred_intf.Deferred.t) ->
            ('k, 'v3, 'comparator) t Async_core.Deferred_intf.Deferred.t
        end
      module Result :
        sig
          type ('a, 'b) t = ('a, 'b) Core.Std.Result.t t
          val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
              val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
            end
          val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val return : 'a -> ('a, 'b) t
          val map : ('a, 'd) t -> f:('a -> 'b) -> ('b, 'd) t
          val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
          val ignore : ('a, 'd) t -> (unit, 'd) t
          val all : ('a, 'd) t list -> ('a list, 'd) t
          val all_ignore : (unit, 'd) t list -> (unit, 'd) t
        end
      module Option :
        sig
          type 'a t = 'a option t
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
            end
          val bind : 'a t -> ('a -> 'b t) -> 'b t
          val return : 'a -> 'a t
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
        end
      val don't_wait_for : unit t -> unit
      type 'a choice = 'a Async_core.Deferred.choice
      val choice : 'a t -> ('a -> 'b) -> 'b choice
      val enabled : 'b choice list -> (unit -> 'b list) t
      val choose : 'b choice list -> 'b t
      val repeat_until_finished :
        'state ->
        ('state -> [ `Finished of 'result | `Repeat of 'state ] t) ->
        'result t
      val forever : 'state -> ('state -> 'state t) -> unit
      val debug_space_leaks : int option ref
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      module Or_error :
        sig
          type 'a t = 'a Core.Std.Or_error.t Async_core.Deferred.t
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
            end
          val bind : 'a t -> ('a -> 'b t) -> 'b t
          val return : 'a -> 'a t
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
          val fail : Core.Std.Error.t -> 'a t
          val ok_exn : 'a t -> 'a Async_core.Deferred.t
          val of_exn : exn -> 'a t
          val of_exn_result :
            ('a, exn) Core.Std.Result.t Async_core.Deferred.t -> 'a t
          val error : string -> 'a -> ('a -> Core.Std.Sexp.t) -> 'b t
          val error_string : string -> 'a t
          val unimplemented : string -> 'a t
          val combine_errors : 'a t list -> 'a list t
          val combine_errors_unit : unit t list -> unit t
          val ok_unit : unit t
          val try_with :
            ?extract_exn:bool ->
            ?name:string -> (unit -> 'a Async_core.Deferred.t) -> 'a t
          val try_with_join :
            ?extract_exn:bool -> ?name:string -> (unit -> 'a t) -> 'a t
          module List :
            sig
              val foldi :
                'a list -> init:'b -> f:(int -> 'b -> 'a -> 'b t) -> 'b t
              val fold : 'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
              val init :
                ?how:Async_core.Deferred_intf.how ->
                int -> f:(int -> 'a t) -> 'a list t
              val iter :
                ?how:Async_core.Deferred_intf.how ->
                'a list -> f:('a -> unit t) -> unit t
              val iteri :
                ?how:Async_core.Deferred_intf.how ->
                'a list -> f:(int -> 'a -> unit t) -> unit t
              val map :
                ?how:Async_core.Deferred_intf.how ->
                'a list -> f:('a -> 'b t) -> 'b list t
              val filter :
                ?how:Async_core.Deferred_intf.how ->
                'a list -> f:('a -> bool t) -> 'a list t
              val filter_map :
                ?how:Async_core.Deferred_intf.how ->
                'a list -> f:('a -> 'b option t) -> 'b list t
              val find : 'a list -> f:('a -> bool t) -> 'a option t
              val find_map : 'a list -> f:('a -> 'b option t) -> 'b option t
              val all : 'a t list -> 'a list t
              val all_unit : unit t list -> unit t
            end
        end
    end
  module Writer :
    sig
      module Id :
        sig
          type t = Async_unix.Writer.Id.t
          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 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_witness = Async_unix.Writer.Id.comparator_witness
          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
          val comparator :
            (t, comparator_witness) Core_kernel.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness) Core_kernel.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, Key.comparator_witness)
                      Core_kernel.Core_map.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> 'a -> '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:'b -> f:('b -> 'a -> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('a -> 'a -> '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 -> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('a -> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val filter :
                    'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                  val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                  val compare_direct :
                    ('a -> 'a -> int) -> 'a t -> 'a t -> int
                  val equal : ('a -> 'a -> 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) ->
                    'a Core_kernel.Validate.check ->
                    'a t Core_kernel.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('a -> 'a -> bool) ->
                    (Key.t *
                     [ `Left of 'a | `Right of 'a | `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:('a -> bool) -> bool
                  val exists : 'a t -> f:('a -> bool) -> bool
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> '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 :
                    ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> '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:'b -> f:('b -> 'a -> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('a -> 'a -> '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 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> '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 Tree.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness) Core_kernel.Comparator.comparator
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, Elt.comparator_witness)
                      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:'b ->
                    f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
                    'b
                  val fold_right :
                    t -> init:'b -> f:(Elt.t -> 'b -> '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:('a -> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel.Core_set.Tree.t ->
                    f:('a -> 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_witness) 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:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.t ->
                f:('a -> 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
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hashable : sig type t = t end
          val hash : t -> int
          val compare : t -> t -> int
          val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.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:('r -> 'a key_) ->
                 get_data:('r -> '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:('r -> '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:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> '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:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> 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:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 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:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> '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:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> 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) ->
                'b 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 :
                ('b -> 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:('r -> 'a key_) ->
                 get_data:('r -> '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:('r -> '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:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> '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:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> 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:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 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:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> '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:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> 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) ->
                'b 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 :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
            end
          module Hash_set :
            sig
              type elt = t
              type 'a hash_set = 'a 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 = 'a Async_unix.Writer.Id.Hash_queue.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('a -> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
              val exists : 'a t -> f:('a -> bool) -> bool
              val for_all : 'a t -> f:('a -> bool) -> bool
              val count : 'a t -> f:('a -> bool) -> int
              val find : 'a t -> f:('a -> bool) -> 'a option
              val find_map : 'a t -> f:('a -> '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 -> 'a -> [ `Key_already_present | `Ok ]
              val enqueue_exn : 'a t -> Key.t -> 'a -> 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:('a -> 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 -> 'a -> [ `No_such_key | `Ok ]
              val replace_exn : 'a t -> Key.t -> 'a -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
              val foldi :
                'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
            end
          val of_int_exn : int -> t
          val to_int_exn : t -> int
          val of_string : string -> t
          val to_string : t -> string
          val create : unit -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_t : t Bin_prot.Type_class.t
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_writer_t : t Bin_prot.Type_class.writer
        end
      type t = Async_unix.Writer.t
      val invariant : t Core_kernel.Invariant_intf.inv
      val io_stats : Async_unix.Io_stats.t
      val stdout : t Core.Std.Lazy.t
      val stderr : t Core.Std.Lazy.t
      type buffer_age_limit =
          [ `At_most of Core.Std.Time.Span.t | `Unlimited ]
      val create :
        ?buf_len:int ->
        ?syscall:[ `Per_cycle | `Periodic of Core.Std.Time.Span.t ] ->
        ?buffer_age_limit:buffer_age_limit ->
        ?raise_when_consumer_leaves:bool -> Async_unix.Fd.t -> t
      val raise_when_consumer_leaves : t -> bool
      val set_raise_when_consumer_leaves : t -> bool -> unit
      val set_buffer_age_limit : t -> buffer_age_limit -> unit
      val consumer_left : t -> unit Async_unix.Import.Deferred.t
      val of_out_channel : out_channel -> Async_unix.Fd.Kind.t -> t
      val open_file :
        ?append:bool ->
        ?close_on_exec:bool ->
        ?perm:int -> string -> t Async_unix.Import.Deferred.t
      val with_file :
        ?perm:int ->
        ?append:bool ->
        ?exclusive:bool ->
        string ->
        f:(t -> 'a Async_unix.Import.Deferred.t) ->
        'a Async_unix.Import.Deferred.t
      val id : t -> Id.t
      val fd : t -> Async_unix.Fd.t
      val set_fd : t -> Async_unix.Fd.t -> unit Async_unix.Import.Deferred.t
      val write : ?pos:int -> ?len:int -> t -> string -> unit
      val write_bigstring :
        ?pos:int -> ?len:int -> t -> Core.Std.Bigstring.t -> unit
      val write_substring : t -> Core.Std.Substring.t -> unit
      val write_bigsubstring : t -> Core.Std.Bigsubstring.t -> unit
      val writef : t -> ('a, unit, string, unit) format4 -> 'a
      val to_formatter : t -> Format.formatter
      val write_char : t -> char -> unit
      val newline : t -> unit
      val write_line : t -> string -> unit
      val write_byte : t -> int -> unit
      val write_sexp : ?hum:bool -> t -> Core.Std.Sexp.t -> unit
      val write_bin_prot :
        t -> 'a Core.Std.Bin_prot.Type_class.writer -> 'a -> unit
      val write_marshal : t -> flags:Marshal.extern_flags list -> 'a -> unit
      val schedule_bigstring :
        t -> ?pos:int -> ?len:int -> Core.Std.Bigstring.t -> unit
      val schedule_bigsubstring : t -> Core.Std.Bigsubstring.t -> unit
      val schedule_iovec :
        t -> Core.Std.Bigstring.t Core.Std.Unix.IOVec.t -> unit
      val schedule_iovecs :
        t ->
        Core.Std.Bigstring.t Core.Std.Unix.IOVec.t Core.Std.Queue.t -> unit
      val flushed : t -> unit Async_unix.Import.Deferred.t
      val flushed_time : t -> Core.Std.Time.t Async_unix.Import.Deferred.t
      val fsync : t -> unit Async_unix.Import.Deferred.t
      val fdatasync : t -> unit Async_unix.Import.Deferred.t
      val send : t -> string -> unit
      val monitor : t -> Async_unix.Import.Monitor.t
      val close :
        ?force_close:unit Async_unix.Import.Deferred.t ->
        t -> unit Async_unix.Import.Deferred.t
      val close_finished : t -> unit Async_unix.Import.Deferred.t
      val is_closed : t -> bool
      val is_open : t -> bool
      val with_close :
        t ->
        f:(unit -> 'a Async_unix.Import.Deferred.t) ->
        'a Async_unix.Import.Deferred.t
      val with_flushed_at_close :
        t ->
        flushed:(unit -> unit Async_unix.Import.Deferred.t) ->
        f:(unit -> 'a Async_unix.Import.Deferred.t) ->
        'a Async_unix.Import.Deferred.t
      val bytes_to_write : t -> int
      val bytes_written : t -> Core.Std.Int63.t
      val bytes_received : t -> Core.Std.Int63.t
      val with_file_atomic :
        ?temp_file:string ->
        ?perm:Core.Std.Unix.file_perm ->
        ?fsync:bool ->
        string ->
        f:(t -> 'a Async_unix.Import.Deferred.t) ->
        'a Async_unix.Import.Deferred.t
      val save :
        ?temp_file:string ->
        ?perm:Core.Std.Unix.file_perm ->
        ?fsync:bool ->
        string -> contents:string -> unit Async_unix.Import.Deferred.t
      val save_lines :
        ?temp_file:string ->
        ?perm:Core.Std.Unix.file_perm ->
        ?fsync:bool ->
        string -> string list -> unit Async_unix.Import.Deferred.t
      val save_sexp :
        ?temp_file:string ->
        ?perm:Core.Std.Unix.file_perm ->
        ?fsync:bool ->
        ?hum:bool ->
        string -> Core.Std.Sexp.t -> unit Async_unix.Import.Deferred.t
      val transfer :
        ?stop:unit Async_unix.Import.Deferred.t ->
        t ->
        'a Async_unix.Import.Pipe.Reader.t ->
        ('a -> unit) -> unit Async_unix.Import.Deferred.t
      val pipe : t -> string Async_unix.Import.Pipe.Writer.t
      val of_pipe :
        Core.Std.Info.t ->
        string Async_unix.Import.Pipe.Writer.t ->
        (t *
         [ `Closed_and_flushed_downstream of
             unit Async_unix.Import.Deferred.t ])
        Async_unix.Import.Deferred.t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val buffer_age_limit_of_sexp : Sexplib.Sexp.t -> buffer_age_limit
      val __buffer_age_limit_of_sexp__ : Sexplib.Sexp.t -> buffer_age_limit
      val sexp_of_buffer_age_limit : buffer_age_limit -> Sexplib.Sexp.t
      val bin_buffer_age_limit :
        buffer_age_limit Core.Std.Bin_prot.Type_class.t
      val bin_read_buffer_age_limit :
        buffer_age_limit Core.Std.Bin_prot.Read.reader
      val __bin_read_buffer_age_limit__ :
        (int -> buffer_age_limit) Core.Std.Bin_prot.Read.reader
      val bin_reader_buffer_age_limit :
        buffer_age_limit Core.Std.Bin_prot.Type_class.reader
      val bin_size_buffer_age_limit :
        buffer_age_limit Core.Std.Bin_prot.Size.sizer
      val bin_write_buffer_age_limit :
        buffer_age_limit Core.Std.Bin_prot.Write.writer
      val bin_writer_buffer_age_limit :
        buffer_age_limit Core.Std.Bin_prot.Type_class.writer
    end
  module Ansi :
    sig
      val kill_line : unit -> unit
      val bell : unit -> unit
      val home_cursor : unit -> unit
      val save_cursor : unit -> unit
      val unsave_cursor : unit -> unit
      type color =
          [ `Black
          | `Blue
          | `Cyan
          | `Green
          | `Magenta
          | `Red
          | `White
          | `Yellow ]
      type attr =
          [ `Bg of color
          | `Black
          | `Blue
          | `Bright
          | `Cyan
          | `Dim
          | `Green
          | `Magenta
          | `Red
          | `Reverse
          | `Underscore
          | `White
          | `Yellow ]
      val printf : attr list -> ('a, out_channel, unit) format -> 'a
      val eprintf : attr list -> ('a, out_channel, unit) format -> 'a
      val output_string : attr list -> out_channel -> string -> unit
      val output : attr list -> out_channel -> string -> int -> int -> unit
      val string_with_attr : attr list -> string -> string
    end
  val is_color_tty : unit -> bool
  val width : unit -> [ `Cols of int | `Not_a_tty | `Not_available ]
  val print_list : out_channel -> (string * Ansi.attr list) list -> unit
  module Log :
    sig
      module Output :
        sig
          val create :
            ?debug:Ansi.attr list ->
            ?info:Ansi.attr list ->
            ?error:Ansi.attr list ->
            Async.Std.Writer.t ->
            Async.Std.Log.Message.t Core.Std.Queue.t -> unit Deferred.t
        end
      module Blocking :
        sig
          module Output :
            sig
              val create :
                ?debug:Ansi.attr list ->
                ?info:Ansi.attr list ->
                ?error:Ansi.attr list ->
                Core.Std.Out_channel.t -> Async.Std.Log.Message.t -> unit
            end
        end
    end
end