sig
  val __pa_ounit_275876e34cf609db118f3d84b799a790 : string
  module Binable :
    sig
      val __pa_ounit_275876e34cf609db118f3d84b799a790 : string
      module type S =
        sig
          type t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.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 type S1 =
        sig
          type 'a t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.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 type S2 =
        sig
          type ('a, 'b) t
          val bin_size_t : ('a, 'b, ('a, 'b) t) Bin_prot.Size.sizer2
          val bin_write_t : ('a, 'b, ('a, 'b) t) Bin_prot.Map_to_safe.writer2
          val bin_write_t_ :
            ('a, 'b, ('a, 'b) t) Bin_prot.Unsafe_write_c.writer2
          val bin_read_t : ('a, 'b, ('a, 'b) t) Bin_prot.Map_to_safe.reader2
          val bin_read_t_ :
            ('a, 'b, ('a, 'b) t) Bin_prot.Unsafe_read_c.reader2
          val bin_read_t__ :
            ('a, 'b, int -> ('a, 'b) t) Bin_prot.Unsafe_read_c.reader2
          val bin_writer_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.writer
          val bin_reader_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.reader
          val bin_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.t
        end
      module List :
        sig
          val length : 'a list -> int
          val hd : 'a list -> 'a
          val tl : 'a list -> 'a list
          val nth : 'a list -> int -> 'a
          val rev : 'a list -> 'a list
          val append : 'a list -> 'a list -> 'a list
          val rev_append : 'a list -> 'a list -> 'a list
          val concat : 'a list list -> 'a list
          val flatten : 'a list list -> 'a list
          val iter : f:('a -> unit) -> 'a list -> unit
          val iteri : f:(int -> 'a -> unit) -> 'a list -> unit
          val map : f:('a -> 'b) -> 'a list -> 'b list
          val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list
          val rev_map : f:('a -> 'b) -> 'a list -> 'b list
          val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a
          val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b
          val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
          val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
          val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
          val fold_left2 :
            f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a
          val fold_right2 :
            f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c
          val for_all : f:('a -> bool) -> 'a list -> bool
          val exists : f:('a -> bool) -> 'a list -> bool
          val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
          val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
          val mem : 'a -> set:'a list -> bool
          val memq : 'a -> set:'a list -> bool
          val find : f:('a -> bool) -> 'a list -> 'a
          val filter : f:('a -> bool) -> 'a list -> 'a list
          val find_all : f:('a -> bool) -> 'a list -> 'a list
          val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
          val assoc : 'a -> ('a * 'b) list -> 'b
          val assq : 'a -> ('a * 'b) list -> 'b
          val mem_assoc : 'a -> map:('a * 'b) list -> bool
          val mem_assq : 'a -> map:('a * 'b) list -> bool
          val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
          val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
          val split : ('a * 'b) list -> 'a list * 'b list
          val combine : 'a list -> 'b list -> ('a * 'b) list
          val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
          val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
          val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
          val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
        end
      module Of_stringable :
        functor (M : Stringable.S) ->
          sig
            val bin_size_t : M.t Bin_prot.Size.sizer
            val bin_write_t : M.t Bin_prot.Map_to_safe.writer
            val bin_write_t_ : M.t Bin_prot.Unsafe_write_c.writer
            val bin_read_t : M.t Bin_prot.Read_ml.reader
            val bin_read_t_ : M.t Bin_prot.Unsafe_read_c.reader
            val bin_read_t__ : (int -> M.t) Bin_prot.Unsafe_read_c.reader
            val bin_writer_t : M.t Bin_prot.Type_class.writer
            val bin_reader_t : M.t Bin_prot.Type_class.reader
            val bin_t : M.t Bin_prot.Type_class.t
          end
      type bigstring =
          (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout)
          Bigarray.Array1.t
      type 'a m = (module S with type t = 'a)
      val of_bigstring :
        (module S with type t = 'a) -> Bin_prot.Common.buf -> 'a
      val create_bigstring :
        int ->
        (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout)
        Bigarray.Array1.t
      val to_bigstring :
        ?prefix_with_length:bool ->
        (module S with type t = 'a) ->
        'a ->
        (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout)
        Bigarray.Array1.t
    end
  module Hashtbl :
    sig
      module Hashable :
        sig
          type 'a t =
            'a Core_hashtbl_intf.Hashable.t = {
            hash : 'a -> int;
            compare : 'a -> 'a -> int;
            sexp_of_t : 'a -> Sexplib.Sexp.t;
          }
          val poly : 'a t
          val of_key :
            (module Core_hashtbl_intf.Key with type t = 'a) -> 'a t
          val hash_param : int -> int -> 'a -> int
          val hash : 'a -> int
        end
      val hash : 'a -> int
      val hash_param : int -> int -> 'a -> int
      type ('a, 'b) t = ('a, 'b) Hashtbl.t
      type 'a key = 'a
      val create :
        ('a key, unit -> ('a, 'b) t)
        Core_hashtbl_intf.create_options_with_hashable
      val of_alist :
        ('a key,
         ('a key * 'b) list ->
         [ `Duplicate_key of 'a key | `Ok of ('a, 'b) t ])
        Core_hashtbl_intf.create_options_with_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_hashtbl_intf.create_options_with_hashable
      val of_alist_exn :
        ('a key, ('a key * 'b) list -> ('a, 'b) t)
        Core_hashtbl_intf.create_options_with_hashable
      val of_alist_multi :
        ('a key, ('a key * 'b) list -> ('a, 'b list) t)
        Core_hashtbl_intf.create_options_with_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_hashtbl_intf.create_options_with_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_hashtbl_intf.create_options_with_hashable
      val create_with_key_exn :
        ('a key, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t)
        Core_hashtbl_intf.create_options_with_hashable
      val group :
        ('a key,
         get_key:('r -> 'a key) ->
         get_data:('r -> 'b) ->
         combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t)
        Core_hashtbl_intf.create_options_with_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 to_alist : ('a, 'b) t -> ('a key * 'b) list
      val validate :
        name:('a key -> string) ->
        'b Validate.check -> ('a, 'b) t Validate.check
      val incr : ?by:int -> ('a, int) t -> 'a key -> unit
      module Poly :
        sig
          type ('a, 'b) t = ('a, 'b) t
          val hashable : 'a Hashable.t
          type 'a key = 'a
          val create :
            ('a key, unit -> ('a, 'b) t)
            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_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_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key, ('a key * 'b) list -> ('a, 'b) t)
            Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key, ('a key * 'b) list -> ('a, 'b list) t)
            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_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_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t)
            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_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 to_alist : ('a, 'b) t -> ('a key * 'b) list
          val validate :
            name:('a key -> string) ->
            'b Validate.check -> ('a, 'b) t Validate.check
          val incr : ?by:int -> ('a, int) t -> 'a key -> unit
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'a) ->
            (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
          val bin_t :
            'a Bin_prot.Type_class.t ->
            'b Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
          val bin_read_t :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            ('a, 'b) t Bin_prot.Read_ml.reader
          val bin_read_t_ :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            ('a, 'b) t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            (int -> ('a, 'b) t) Bin_prot.Unsafe_read_c.reader
          val bin_reader_t :
            'a Bin_prot.Type_class.reader ->
            'b Bin_prot.Type_class.reader ->
            ('a, 'b) t Bin_prot.Type_class.reader
          val bin_size_t :
            'a Bin_prot.Size.sizer ->
            'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
          val bin_write_t :
            'a Bin_prot.Unsafe_write_c.writer ->
            'b Bin_prot.Unsafe_write_c.writer ->
            ('a, 'b) t Bin_prot.Write_ml.writer
          val bin_write_t_ :
            'a Bin_prot.Unsafe_write_c.writer ->
            'b Bin_prot.Unsafe_write_c.writer ->
            ('a, 'b) t Bin_prot.Unsafe_write_c.writer
          val bin_writer_t :
            'a Bin_prot.Type_class.writer ->
            'b Bin_prot.Type_class.writer ->
            ('a, 'b) t Bin_prot.Type_class.writer
        end
      module type Key = Core_hashtbl_intf.Key
      module type Key_binable = Core_hashtbl_intf.Key_binable
      module type S =
        sig
          type key
          type ('a, 'b) hashtbl = ('a, 'b) t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Validate.check -> ('a, 'b) t_ 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 type S_binable =
        sig
          type key
          type ('a, 'b) hashtbl = ('a, 'b) t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Validate.check -> ('a, 'b) t_ 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
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.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 Make :
        functor (Key : Key) ->
          sig
            type key = Key.t
            type ('a, 'b) hashtbl = ('a, 'b) t
            type 'b t = (key, 'b) hashtbl
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_hashtbl_intf.Hashable.t
            val create :
              ('a key_, unit -> ('a, 'b) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
              Core_hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
              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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
            val validate :
              name:('a key_ -> string) ->
              'b Validate.check -> ('a, 'b) t_ 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 Make_binable :
        functor (Key : Key_binable) ->
          sig
            type key = Key.t
            type ('a, 'b) hashtbl = ('a, 'b) t
            type 'b t = (key, 'b) hashtbl
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_hashtbl_intf.Hashable.t
            val create :
              ('a key_, unit -> ('a, 'b) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
              Core_hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
              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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
            val validate :
              name:('a key_ -> string) ->
              'b Validate.check -> ('a, 'b) t_ 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
            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
            val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
            val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
            val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
            val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_read_t__ :
              ('a, int -> 'a t) Bin_prot.Unsafe_read_c.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
      val sexp_of_t :
        ('a -> Sexplib.Sexp.t) ->
        ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
    end
  module type S =
    sig
      type t
      module Hashable : sig type t = t end
      val hash : t -> int
      val compare : t -> t -> int
      val hashable : t Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Validate.check -> ('a, 'b) t_ 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 Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_) Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            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
          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
      module Hash_heap :
        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
          val create : ?min_size:int -> ('a -> 'a -> int) -> 'a t
          val copy : 'a t -> 'a t
          val push :
            'a t -> key:Key.t -> data:'a -> [ `Key_already_present | `Ok ]
          val push_exn : 'a t -> key:Key.t -> data:'a -> unit
          val replace : 'a t -> key:Key.t -> data:'a -> unit
          val remove : 'a t -> Key.t -> unit
          val mem : 'a t -> Key.t -> bool
          val top : 'a t -> 'a option
          val top_exn : 'a t -> 'a
          val top_with_key : 'a t -> (Key.t * 'a) option
          val top_with_key_exn : 'a t -> Key.t * 'a
          val pop_with_key : 'a t -> (Key.t * 'a) option
          val pop_with_key_exn : 'a t -> Key.t * 'a
          val pop : 'a t -> 'a option
          val pop_exn : 'a t -> 'a
          val cond_pop_with_key :
            'a t -> (key:Key.t -> data:'a -> bool) -> (Key.t * 'a) option
          val cond_pop : 'a t -> ('a -> bool) -> 'a option
          val find : 'a t -> Key.t -> 'a option
          val find_pop : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val find_pop_exn : 'a t -> Key.t -> 'a
          val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val iter_vals : 'a t -> f:('a -> unit) -> unit
          val length : 'a t -> int
        end
    end
  module Make :
    functor (T : Hashtbl.Key) ->
      sig
        module Hashable : sig type t = T.t end
        val hash : T.t -> int
        val compare : T.t -> T.t -> int
        val hashable : T.t Hashtbl.Hashable.t
        module Table :
          sig
            type key = T.t
            type ('a, 'b) hashtbl = ('a, 'b) Hashtbl.t
            type 'b t = (key, 'b) hashtbl
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_hashtbl_intf.Hashable.t
            val create :
              ('a key_, unit -> ('a, 'b) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
              Core_hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
              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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
            val validate :
              name:('a key_ -> string) ->
              'b Validate.check -> ('a, 'b) t_ 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.t
            type 'a hash_set = 'a Hash_set.t
            type t = elt hash_set
            type 'a t_ = t
            type 'a elt_ = elt
            val create :
              ('a, unit -> 'a t_)
              Hash_set_intf.create_options_without_hashable
            val of_list :
              ('a, 'a elt_ list -> 'a t_)
              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.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 = 'a Hashable.Make(T).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
        module Hash_heap :
          sig
            module Key :
              sig
                type t = 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 = 'a Hashable.Make(T).Hash_heap.t
            val create : ?min_size:int -> ('a -> 'a -> int) -> 'a t
            val copy : 'a t -> 'a t
            val push :
              'a t -> key:Key.t -> data:'a -> [ `Key_already_present | `Ok ]
            val push_exn : 'a t -> key:Key.t -> data:'a -> unit
            val replace : 'a t -> key:Key.t -> data:'a -> unit
            val remove : 'a t -> Key.t -> unit
            val mem : 'a t -> Key.t -> bool
            val top : 'a t -> 'a option
            val top_exn : 'a t -> 'a
            val top_with_key : 'a t -> (Key.t * 'a) option
            val top_with_key_exn : 'a t -> Key.t * 'a
            val pop_with_key : 'a t -> (Key.t * 'a) option
            val pop_with_key_exn : 'a t -> Key.t * 'a
            val pop : 'a t -> 'a option
            val pop_exn : 'a t -> 'a
            val cond_pop_with_key :
              'a t -> (key:Key.t -> data:'a -> bool) -> (Key.t * 'a) option
            val cond_pop : 'a t -> ('a -> bool) -> 'a option
            val find : 'a t -> Key.t -> 'a option
            val find_pop : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val find_pop_exn : 'a t -> Key.t -> 'a
            val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter_vals : 'a t -> f:('a -> unit) -> unit
            val length : 'a t -> int
          end
      end
  module type S_binable =
    sig
      type t
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            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_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_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Validate.check -> ('a, 'b) t_ 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
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.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 Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_) Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.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 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
          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
      module Hash_heap :
        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
          val create : ?min_size:int -> ('a -> 'a -> int) -> 'a t
          val copy : 'a t -> 'a t
          val push :
            'a t -> key:Key.t -> data:'a -> [ `Key_already_present | `Ok ]
          val push_exn : 'a t -> key:Key.t -> data:'a -> unit
          val replace : 'a t -> key:Key.t -> data:'a -> unit
          val remove : 'a t -> Key.t -> unit
          val mem : 'a t -> Key.t -> bool
          val top : 'a t -> 'a option
          val top_exn : 'a t -> 'a
          val top_with_key : 'a t -> (Key.t * 'a) option
          val top_with_key_exn : 'a t -> Key.t * 'a
          val pop_with_key : 'a t -> (Key.t * 'a) option
          val pop_with_key_exn : 'a t -> Key.t * 'a
          val pop : 'a t -> 'a option
          val pop_exn : 'a t -> 'a
          val cond_pop_with_key :
            'a t -> (key:Key.t -> data:'a -> bool) -> (Key.t * 'a) option
          val cond_pop : 'a t -> ('a -> bool) -> 'a option
          val find : 'a t -> Key.t -> 'a option
          val find_pop : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val find_pop_exn : 'a t -> Key.t -> 'a
          val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val iter_vals : 'a t -> f:('a -> unit) -> unit
          val length : 'a t -> int
        end
    end
  module Make_binable :
    functor (T : Hashtbl.Key_binable) ->
      sig
        module Hashable : sig type t = T.t end
        val hash : T.t -> int
        val hashable : T.t Hashtbl.Hashable.t
        module Table :
          sig
            type key = T.t
            type ('a, 'b) hashtbl = ('a, 'b) Hashtbl.t
            type 'b t = (key, 'b) hashtbl
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_hashtbl_intf.Hashable.t
            val create :
              ('a key_, unit -> ('a, 'b) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
              Core_hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
              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_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_hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
              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_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 to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
            val validate :
              name:('a key_ -> string) ->
              'b Validate.check -> ('a, 'b) t_ 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
            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
            val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
            val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
            val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
            val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_read_t__ :
              ('a, int -> 'a t) Bin_prot.Unsafe_read_c.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 Hash_set :
          sig
            type elt = T.t
            type 'a hash_set = 'a Hash_set.t
            type t = elt hash_set
            type 'a t_ = t
            type 'a elt_ = elt
            val create :
              ('a, unit -> 'a t_)
              Hash_set_intf.create_options_without_hashable
            val of_list :
              ('a, 'a elt_ list -> 'a t_)
              Hash_set_intf.create_options_without_hashable
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
            val bin_size_t : t Bin_prot.Size.sizer
            val bin_write_t : t Bin_prot.Map_to_safe.writer
            val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
            val bin_read_t : t Bin_prot.Read_ml.reader
            val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
            val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.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 Hash_queue :
          sig
            module Key :
              sig
                type t = 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 = 'a Hashable.Make_binable(T).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
        module Hash_heap :
          sig
            module Key :
              sig
                type t = 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 = 'a Hashable.Make_binable(T).Hash_heap.t
            val create : ?min_size:int -> ('a -> 'a -> int) -> 'a t
            val copy : 'a t -> 'a t
            val push :
              'a t -> key:Key.t -> data:'a -> [ `Key_already_present | `Ok ]
            val push_exn : 'a t -> key:Key.t -> data:'a -> unit
            val replace : 'a t -> key:Key.t -> data:'a -> unit
            val remove : 'a t -> Key.t -> unit
            val mem : 'a t -> Key.t -> bool
            val top : 'a t -> 'a option
            val top_exn : 'a t -> 'a
            val top_with_key : 'a t -> (Key.t * 'a) option
            val top_with_key_exn : 'a t -> Key.t * 'a
            val pop_with_key : 'a t -> (Key.t * 'a) option
            val pop_with_key_exn : 'a t -> Key.t * 'a
            val pop : 'a t -> 'a option
            val pop_exn : 'a t -> 'a
            val cond_pop_with_key :
              'a t -> (key:Key.t -> data:'a -> bool) -> (Key.t * 'a) option
            val cond_pop : 'a t -> ('a -> bool) -> 'a option
            val find : 'a t -> Key.t -> 'a option
            val find_pop : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val find_pop_exn : 'a t -> Key.t -> 'a
            val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter_vals : 'a t -> f:('a -> unit) -> unit
            val length : 'a t -> int
          end
      end
end