sig
  module type Key =
    sig
      type 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 compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val _squelch_unused_module_warning_ : unit
        end
      type comparator
      val comparator : (t, comparator) Core.Comparator.t
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core.Comparator.t_
            end
          type ('a, 'b, 'c) map = ('a, 'b, 'c) Core.Core_map.t
          type ('a, 'b, 'c) tree = ('a, 'b, 'c) Core.Core_map.tree
          type 'v t = (t, 'v, comparator) map
          type ('k, 'v, 'comparator) t_ = 'v t
          type 'a key_ = Key.t
          type ('a, 'b, 'c) options =
              ('a, 'b, 'c) Core.Core_map_intf.without_comparator
          val empty : ('k, 'comparator, ('k, 'a, 'comparator) t_) options
          val singleton :
            ('k, 'comparator, 'k key_ -> 'v -> ('k, 'v, 'comparator) t_)
            options
          val of_sorted_array :
            ('k, 'comparator,
             ('k key_ * 'v) array -> ('k, 'v, 'comparator) t_ Core.Or_error.t)
            options
          val of_sorted_array_unchecked :
            ('k, 'comparator,
             ('k key_ * 'v) array -> ('k, 'v, 'comparator) t_)
            options
          val of_alist :
            ('k, 'comparator,
             ('k key_ * 'v) list ->
             [ `Duplicate_key of 'k key_ | `Ok of ('k, 'v, 'comparator) t_ ])
            options
          val of_alist_exn :
            ('k, 'comparator,
             ('k key_ * 'v) list -> ('k, 'v, 'comparator) t_)
            options
          val of_alist_multi :
            ('k, 'comparator,
             ('k key_ * 'v) list -> ('k, 'v list, 'comparator) t_)
            options
          val of_alist_fold :
            ('k, 'comparator,
             ('k key_ * 'v1) list ->
             init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_)
            options
          val of_tree :
            ('k, 'comparator,
             ('k key_, 'v, 'comparator) tree -> ('k, 'v, 'comparator) t_)
            options
          val invariants :
            ('k, 'comparator, ('k, 'v, 'comparator) t_ -> bool) options
          val is_empty : ('a, 'b, 'c) t_ -> bool
          val length : ('a, 'b, 'c) t_ -> int
          val add :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             key:'k key_ -> data:'v -> ('k, 'v, 'comparator) t_)
            options
          val add_multi :
            ('k, 'comparator,
             ('k, 'v list, 'comparator) t_ ->
             key:'k key_ -> data:'v -> ('k, 'v list, 'comparator) t_)
            options
          val change :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             'k key_ -> ('v option -> 'v option) -> ('k, 'v, 'comparator) t_)
            options
          val find :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v option)
            options
          val find_exn :
            ('k, 'comparator, ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v)
            options
          val remove :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k, 'v, 'comparator) t_)
            options
          val mem :
            ('k, 'comparator, ('k, 'a, 'comparator) t_ -> 'k key_ -> bool)
            options
          val iter :
            ('k, 'v, 'a) t_ -> f:(key:'k key_ -> data:'v -> unit) -> unit
          val iter2 :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             ('k, 'v2, 'comparator) t_ ->
             f:(key:'k key_ ->
                data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
                unit) ->
             unit)
            options
          val map :
            ('k, 'v1, 'comparator) t_ ->
            f:('v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
          val mapi :
            ('k, 'v1, 'comparator) t_ ->
            f:(key:'k key_ -> data:'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
          val fold :
            ('k, 'v, 'b) t_ ->
            init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
          val fold_right :
            ('k, 'v, 'b) t_ ->
            init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
          val filter :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             f:(key:'k key_ -> data:'v -> bool) -> ('k, 'v, 'comparator) t_)
            options
          val filter_map :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             f:('v1 -> 'v2 option) -> ('k, 'v2, 'comparator) t_)
            options
          val filter_mapi :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             f:(key:'k key_ -> data:'v1 -> 'v2 option) ->
             ('k, 'v2, 'comparator) t_)
            options
          val compare_direct :
            ('k, 'comparator,
             ('v -> 'v -> int) ->
             ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> int)
            options
          val equal :
            ('k, 'comparator,
             ('v -> 'v -> bool) ->
             ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> bool)
            options
          val keys : ('k, 'a, 'b) t_ -> 'k key_ list
          val data : ('a, 'v, 'b) t_ -> 'v list
          val to_alist : ('k, 'v, 'a) t_ -> ('k key_ * 'v) list
          val merge :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             ('k, 'v2, 'comparator) t_ ->
             f:(key:'k key_ ->
                [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
                'v3 option) ->
             ('k, 'v3, 'comparator) t_)
            options
          val symmetric_diff :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             ('k, 'v, 'comparator) t_ ->
             data_equal:('v -> 'v -> bool) ->
             ('k key_ * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ])
             list)
            options
          val min_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
          val min_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
          val max_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
          val max_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
          val for_all : ('k, 'v, 'a) t_ -> f:('v -> bool) -> bool
          val exists : ('k, 'v, 'a) t_ -> f:('v -> bool) -> bool
          val fold_range_inclusive :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             min:'k key_ ->
             max:'k key_ ->
             init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a)
            options
          val range_to_alist :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             min:'k key_ -> max:'k key_ -> ('k key_ * 'v) list)
            options
          val prev_key :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
            options
          val next_key :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
            options
          val rank :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> int option)
            options
          val to_tree :
            ('k, 'v, 'comparator) t_ -> ('k key_, 'v, 'comparator) tree
          module Tree :
            sig
              type 'v t = (Key.t, 'v, comparator) tree
              type ('k, 'v, 'c) t_ = 'v t
              val empty : ('k, 'comparator, ('k, 'a, 'comparator) t_) options
              val singleton :
                ('k, 'comparator, 'k key_ -> 'v -> ('k, 'v, 'comparator) t_)
                options
              val of_sorted_array :
                ('k, 'comparator,
                 ('k key_ * 'v) array ->
                 ('k, 'v, 'comparator) t_ Core.Or_error.t)
                options
              val of_sorted_array_unchecked :
                ('k, 'comparator,
                 ('k key_ * 'v) array -> ('k, 'v, 'comparator) t_)
                options
              val of_alist :
                ('k, 'comparator,
                 ('k key_ * 'v) list ->
                 [ `Duplicate_key of 'k key_
                 | `Ok of ('k, 'v, 'comparator) t_ ])
                options
              val of_alist_exn :
                ('k, 'comparator,
                 ('k key_ * 'v) list -> ('k, 'v, 'comparator) t_)
                options
              val of_alist_multi :
                ('k, 'comparator,
                 ('k key_ * 'v) list -> ('k, 'v list, 'comparator) t_)
                options
              val of_alist_fold :
                ('k, 'comparator,
                 ('k key_ * 'v1) list ->
                 init:'v2 ->
                 f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_)
                options
              val of_tree :
                ('k, 'comparator,
                 ('k key_, 'v, 'comparator) tree -> ('k, 'v, 'comparator) t_)
                options
              val invariants :
                ('k, 'comparator, ('k, 'v, 'comparator) t_ -> bool) options
              val is_empty : ('a, 'b, 'c) t_ -> bool
              val length : ('a, 'b, 'c) t_ -> int
              val add :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ ->
                 key:'k key_ -> data:'v -> ('k, 'v, 'comparator) t_)
                options
              val add_multi :
                ('k, 'comparator,
                 ('k, 'v list, 'comparator) t_ ->
                 key:'k key_ -> data:'v -> ('k, 'v list, 'comparator) t_)
                options
              val change :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ ->
                 'k key_ ->
                 ('v option -> 'v option) -> ('k, 'v, 'comparator) t_)
                options
              val find :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v option)
                options
              val find_exn :
                ('k, 'comparator, ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v)
                options
              val remove :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ ->
                 'k key_ -> ('k, 'v, 'comparator) t_)
                options
              val mem :
                ('k, 'comparator,
                 ('k, 'a, 'comparator) t_ -> 'k key_ -> bool)
                options
              val iter :
                ('k, 'v, 'a) t_ -> f:(key:'k key_ -> data:'v -> unit) -> unit
              val iter2 :
                ('k, 'comparator,
                 ('k, 'v1, 'comparator) t_ ->
                 ('k, 'v2, 'comparator) t_ ->
                 f:(key:'k key_ ->
                    data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
                    unit) ->
                 unit)
                options
              val map :
                ('k, 'v1, 'comparator) t_ ->
                f:('v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
              val mapi :
                ('k, 'v1, 'comparator) t_ ->
                f:(key:'k key_ -> data:'v1 -> 'v2) ->
                ('k, 'v2, 'comparator) t_
              val fold :
                ('k, 'v, 'b) t_ ->
                init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
              val fold_right :
                ('k, 'v, 'b) t_ ->
                init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
              val filter :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ ->
                 f:(key:'k key_ -> data:'v -> bool) ->
                 ('k, 'v, 'comparator) t_)
                options
              val filter_map :
                ('k, 'comparator,
                 ('k, 'v1, 'comparator) t_ ->
                 f:('v1 -> 'v2 option) -> ('k, 'v2, 'comparator) t_)
                options
              val filter_mapi :
                ('k, 'comparator,
                 ('k, 'v1, 'comparator) t_ ->
                 f:(key:'k key_ -> data:'v1 -> 'v2 option) ->
                 ('k, 'v2, 'comparator) t_)
                options
              val compare_direct :
                ('k, 'comparator,
                 ('v -> 'v -> int) ->
                 ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> int)
                options
              val equal :
                ('k, 'comparator,
                 ('v -> 'v -> bool) ->
                 ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> bool)
                options
              val keys : ('k, 'a, 'b) t_ -> 'k key_ list
              val data : ('a, 'v, 'b) t_ -> 'v list
              val to_alist : ('k, 'v, 'a) t_ -> ('k key_ * 'v) list
              val merge :
                ('k, 'comparator,
                 ('k, 'v1, 'comparator) t_ ->
                 ('k, 'v2, 'comparator) t_ ->
                 f:(key:'k key_ ->
                    [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
                    'v3 option) ->
                 ('k, 'v3, 'comparator) t_)
                options
              val symmetric_diff :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ ->
                 ('k, 'v, 'comparator) t_ ->
                 data_equal:('v -> 'v -> bool) ->
                 ('k key_ *
                  [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ])
                 list)
                options
              val min_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
              val min_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
              val max_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
              val max_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
              val for_all : ('k, 'v, 'a) t_ -> f:('v -> bool) -> bool
              val exists : ('k, 'v, 'a) t_ -> f:('v -> bool) -> bool
              val fold_range_inclusive :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ ->
                 min:'k key_ ->
                 max:'k key_ ->
                 init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a)
                options
              val range_to_alist :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ ->
                 min:'k key_ -> max:'k key_ -> ('k key_ * 'v) list)
                options
              val prev_key :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
                options
              val next_key :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
                options
              val rank :
                ('k, 'comparator,
                 ('k, 'v, 'comparator) t_ -> 'k key_ -> int option)
                options
              val to_tree :
                ('k, 'v, 'comparator) t_ -> ('k key_, 'v, 'comparator) tree
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v) -> Sexplib.Sexp.t -> 'v t
              val sexp_of_t :
                ('v -> Sexplib.Sexp.t) -> 'v t -> Sexplib.Sexp.t
            end
          val compare : ('v -> 'v -> int) -> 'v t -> 'v t -> int
          val t_of_sexp : (Sexplib.Sexp.t -> 'v) -> Sexplib.Sexp.t -> 'v t
          val sexp_of_t : ('v -> Sexplib.Sexp.t) -> 'v t -> Sexplib.Sexp.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core.Comparator.t_
            end
          type ('a, 'b) set = ('a, 'b) Core.Core_set.t
          type ('a, 'b) tree = ('a, 'b) Core.Core_set.tree
          type t = (t, comparator) set
          type ('a, 'comparator) t_ = t
          type 'a elt_ = Elt.t
          val singleton :
            ('a, 'comparator, 'a elt_ -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val union_list :
            ('a, 'comparator,
             ('a, 'comparator) t_ list -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val of_list :
            ('a, 'comparator, 'a elt_ list -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val of_array :
            ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val of_sorted_array :
            ('a, 'comparator,
             'a elt_ array -> ('a, 'comparator) t_ Core.Or_error.t)
            Core.Core_set_intf.without_comparator
          val of_sorted_array_unchecked :
            ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val stable_dedup_list :
            ('a, 'b, 'a elt_ list -> 'a elt_ list)
            Core.Core_set_intf.without_comparator
          val map :
            ('b, 'comparator,
             ('a, 'c) set -> f:('a -> 'b elt_) -> ('b, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val filter_map :
            ('b, 'comparator,
             ('a, 'c) set -> f:('a -> 'b elt_ option) -> ('b, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val of_tree :
            ('a, 'comparator,
             ('a elt_, 'comparator) tree -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val iter : ('a, 'b) t_ -> f:('a elt_ -> unit) -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'accum -> f:('accum -> 'a elt_ -> 'accum) -> 'accum
          val exists : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
          val for_all : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
          val count : ('a, 'b) t_ -> f:('a elt_ -> bool) -> int
          val find : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_ option
          val find_map : ('a, 'c) t_ -> f:('a elt_ -> 'b option) -> 'b option
          val to_list : ('a, 'b) t_ -> 'a elt_ list
          val to_array : ('a, 'b) t_ -> 'a elt_ array
          val invariants :
            ('a, 'comparator, ('a, 'comparator) t_ -> bool)
            Core.Core_set_intf.without_comparator
          val mem :
            ('a, 'comparator, ('a, 'comparator) t_ -> 'a elt_ -> bool)
            Core.Core_set_intf.without_comparator
          val add :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val remove :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val union :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val inter :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val diff :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val compare_direct :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> int)
            Core.Core_set_intf.without_comparator
          val equal :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
            Core.Core_set_intf.without_comparator
          val subset :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
            Core.Core_set_intf.without_comparator
          val fold_until :
            ('a, 'c) t_ ->
            init:'b ->
            f:('b -> 'a elt_ -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right :
            ('a, 'c) t_ -> init:'b -> f:('a elt_ -> 'b -> 'b) -> 'b
          val iter2 :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ ->
             f:([ `Both of 'a elt_ * 'a elt_
                | `Left of 'a elt_
                | `Right of 'a elt_ ] -> unit) ->
             unit)
            Core.Core_set_intf.without_comparator
          val filter :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             f:('a elt_ -> bool) -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val partition_tf :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             f:('a elt_ -> bool) ->
             ('a, 'comparator) t_ * ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val elements : ('a, 'b) t_ -> 'a elt_ list
          val min_elt : ('a, 'b) t_ -> 'a elt_ option
          val min_elt_exn : ('a, 'b) t_ -> 'a elt_
          val max_elt : ('a, 'b) t_ -> 'a elt_ option
          val max_elt_exn : ('a, 'b) t_ -> 'a elt_
          val choose : ('a, 'b) t_ -> 'a elt_ option
          val choose_exn : ('a, 'b) t_ -> 'a elt_
          val split :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             'a elt_ -> ('a, 'comparator) t_ * bool * ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val group_by :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             equiv:('a elt_ -> 'a elt_ -> bool) -> ('a, 'comparator) t_ list)
            Core.Core_set_intf.without_comparator
          val find_exn : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_
          val find_index : ('a, 'b) t_ -> int -> 'a elt_ option
          val remove_index :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> int -> ('a, 'comparator) t_)
            Core.Core_set_intf.without_comparator
          val to_tree : ('a, 'comparator) t_ -> ('a elt_, 'comparator) tree
          val empty : t
          module Tree :
            sig
              type t = (Elt.t, comparator) tree
              type ('a, 'b) t_ = t
              val empty :
                ('a, 'comparator, ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val singleton :
                ('a, 'comparator, 'a elt_ -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val union_list :
                ('a, 'comparator,
                 ('a, 'comparator) t_ list -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val of_list :
                ('a, 'comparator, 'a elt_ list -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val of_array :
                ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val of_sorted_array :
                ('a, 'comparator,
                 'a elt_ array -> ('a, 'comparator) t_ Core.Or_error.t)
                Core.Core_set_intf.without_comparator
              val of_sorted_array_unchecked :
                ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val stable_dedup_list :
                ('a, 'b, 'a elt_ list -> 'a elt_ list)
                Core.Core_set_intf.without_comparator
              val map :
                ('b, 'comparator,
                 ('a, 'c) tree -> f:('a -> 'b elt_) -> ('b, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val filter_map :
                ('b, 'comparator,
                 ('a, 'c) tree ->
                 f:('a -> 'b elt_ option) -> ('b, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val of_tree :
                ('a, 'comparator,
                 ('a elt_, 'comparator) tree -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val iter : ('a, 'b) t_ -> f:('a elt_ -> unit) -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'accum -> f:('accum -> 'a elt_ -> 'accum) -> 'accum
              val exists : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
              val for_all : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
              val count : ('a, 'b) t_ -> f:('a elt_ -> bool) -> int
              val find : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_ option
              val find_map :
                ('a, 'c) t_ -> f:('a elt_ -> 'b option) -> 'b option
              val to_list : ('a, 'b) t_ -> 'a elt_ list
              val to_array : ('a, 'b) t_ -> 'a elt_ array
              val invariants :
                ('a, 'comparator, ('a, 'comparator) t_ -> bool)
                Core.Core_set_intf.without_comparator
              val mem :
                ('a, 'comparator, ('a, 'comparator) t_ -> 'a elt_ -> bool)
                Core.Core_set_intf.without_comparator
              val add :
                ('a, 'comparator,
                 ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val remove :
                ('a, 'comparator,
                 ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val union :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 ('a, 'comparator) t_ -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val inter :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 ('a, 'comparator) t_ -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val diff :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 ('a, 'comparator) t_ -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val compare_direct :
                ('a, 'comparator,
                 ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> int)
                Core.Core_set_intf.without_comparator
              val equal :
                ('a, 'comparator,
                 ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
                Core.Core_set_intf.without_comparator
              val subset :
                ('a, 'comparator,
                 ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
                Core.Core_set_intf.without_comparator
              val fold_until :
                ('a, 'c) t_ ->
                init:'b ->
                f:('b -> 'a elt_ -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right :
                ('a, 'c) t_ -> init:'b -> f:('a elt_ -> 'b -> 'b) -> 'b
              val iter2 :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 ('a, 'comparator) t_ ->
                 f:([ `Both of 'a elt_ * 'a elt_
                    | `Left of 'a elt_
                    | `Right of 'a elt_ ] -> unit) ->
                 unit)
                Core.Core_set_intf.without_comparator
              val filter :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 f:('a elt_ -> bool) -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val partition_tf :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 f:('a elt_ -> bool) ->
                 ('a, 'comparator) t_ * ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val elements : ('a, 'b) t_ -> 'a elt_ list
              val min_elt : ('a, 'b) t_ -> 'a elt_ option
              val min_elt_exn : ('a, 'b) t_ -> 'a elt_
              val max_elt : ('a, 'b) t_ -> 'a elt_ option
              val max_elt_exn : ('a, 'b) t_ -> 'a elt_
              val choose : ('a, 'b) t_ -> 'a elt_ option
              val choose_exn : ('a, 'b) t_ -> 'a elt_
              val split :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 'a elt_ ->
                 ('a, 'comparator) t_ * bool * ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val group_by :
                ('a, 'comparator,
                 ('a, 'comparator) t_ ->
                 equiv:('a elt_ -> 'a elt_ -> bool) ->
                 ('a, 'comparator) t_ list)
                Core.Core_set_intf.without_comparator
              val find_exn : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_
              val find_index : ('a, 'b) t_ -> int -> 'a elt_ option
              val remove_index :
                ('a, 'comparator,
                 ('a, 'comparator) t_ -> int -> ('a, 'comparator) t_)
                Core.Core_set_intf.without_comparator
              val to_tree :
                ('a, 'comparator) t_ -> ('a elt_, 'comparator) tree
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
            end
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
        end
      module Packed_array :
        sig
          type t
          val length : t -> int
          val unsafe_get : t -> int -> Set.Elt.t
          val unsafe_slice : t -> pos:int -> len:int -> t
          val bin_elt : Set.Elt.t Core.Std.Bin_prot.Type_class.t
          val bin_read_elt : Set.Elt.t Core.Std.Bin_prot.Read_ml.reader
          val bin_read_elt_ :
            Set.Elt.t Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_elt__ :
            (int -> Set.Elt.t) Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_elt : Set.Elt.t Core.Std.Bin_prot.Type_class.reader
          val bin_size_elt : Set.Elt.t Core.Std.Bin_prot.Size.sizer
          val bin_write_elt : Set.Elt.t Core.Std.Bin_prot.Write_ml.writer
          val bin_write_elt_ :
            Set.Elt.t Core.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_elt : Set.Elt.t Core.Std.Bin_prot.Type_class.writer
          val elt_of_sexp : Sexplib.Sexp.t -> Set.Elt.t
          val sexp_of_elt : Set.Elt.t -> Sexplib.Sexp.t
          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
          val get : t -> int -> Set.Elt.t
          val slice : t -> pos:int -> len:int -> t
          val iter : t -> f:(Set.Elt.t -> unit) -> unit
          val fold : t -> init:'a -> f:('a -> Set.Elt.t -> 'a) -> 'a
          val of_array : Set.Elt.t array -> t
          val to_array : t -> Set.Elt.t array
          val of_list : Set.Elt.t list -> t
          val to_list : t -> Set.Elt.t list
          val empty : t
        end
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core.Std.Bin_prot.Read_ml.reader
      val bin_read_t_ : t Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ : (int -> t) Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write_ml.writer
      val bin_write_t_ : t Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module type Value =
    sig
      type t
      module Packed_array :
        sig
          type t
          val length : t -> int
          val unsafe_get : t -> int -> t
          val unsafe_slice : t -> pos:int -> len:int -> t
          val bin_elt : t Core.Std.Bin_prot.Type_class.t
          val bin_read_elt : t Core.Std.Bin_prot.Read_ml.reader
          val bin_read_elt_ : t Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_elt__ :
            (int -> t) Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_elt : t Core.Std.Bin_prot.Type_class.reader
          val bin_size_elt : t Core.Std.Bin_prot.Size.sizer
          val bin_write_elt : t Core.Std.Bin_prot.Write_ml.writer
          val bin_write_elt_ : t Core.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_elt : t Core.Std.Bin_prot.Type_class.writer
          val elt_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_elt : t -> Sexplib.Sexp.t
          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
          val get : t -> int -> t
          val slice : t -> pos:int -> len:int -> t
          val iter : t -> f:(t -> unit) -> unit
          val fold : t -> init:'a -> f:('a -> t -> 'a) -> 'a
          val of_array : t array -> t
          val to_array : t -> t array
          val of_list : t list -> t
          val to_list : t -> t list
          val empty : t
        end
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core.Std.Bin_prot.Read_ml.reader
      val bin_read_t_ : t Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ : (int -> t) Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write_ml.writer
      val bin_write_t_ : t Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module type S =
    sig
      type t
      type key
      type value
      val empty : t
      val of_alist : (key * value) list -> t
      val to_alist : t -> (key * value) list
      val of_aarray : (key * value) array -> t
      val of_sorted_aarray : (key * value) array -> t
      val of_hashtbl : (key, value) Core.Std.Hashtbl.t -> t
      val find : t -> key -> value option
      val mem : t -> key -> bool
      val iter : t -> f:(key:key -> data:value -> unit) -> unit
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core.Std.Bin_prot.Read_ml.reader
      val bin_read_t_ : t Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ : (int -> t) Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write_ml.writer
      val bin_write_t_ : t Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_key : key Core.Std.Bin_prot.Type_class.t
      val bin_read_key : key Core.Std.Bin_prot.Read_ml.reader
      val bin_read_key_ : key Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_key__ :
        (int -> key) Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_key : key Core.Std.Bin_prot.Type_class.reader
      val bin_size_key : key Core.Std.Bin_prot.Size.sizer
      val bin_write_key : key Core.Std.Bin_prot.Write_ml.writer
      val bin_write_key_ : key Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_key : key Core.Std.Bin_prot.Type_class.writer
      val key_of_sexp : Sexplib.Sexp.t -> key
      val sexp_of_key : key -> Sexplib.Sexp.t
      val bin_value : value Core.Std.Bin_prot.Type_class.t
      val bin_read_value : value Core.Std.Bin_prot.Read_ml.reader
      val bin_read_value_ : value Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_value__ :
        (int -> value) Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_value : value Core.Std.Bin_prot.Type_class.reader
      val bin_size_value : value Core.Std.Bin_prot.Size.sizer
      val bin_write_value : value Core.Std.Bin_prot.Write_ml.writer
      val bin_write_value_ : value Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_value : value Core.Std.Bin_prot.Type_class.writer
      val value_of_sexp : Sexplib.Sexp.t -> value
      val sexp_of_value : value -> Sexplib.Sexp.t
    end
  module Make :
    functor (K : Key) ->
      functor (V : Value) ->
        sig
          type t = Packed_map.Make(K)(V).t
          val empty : t
          val of_alist : (K.t * V.t) list -> t
          val to_alist : t -> (K.t * V.t) list
          val of_aarray : (K.t * V.t) array -> t
          val of_sorted_aarray : (K.t * V.t) array -> t
          val of_hashtbl : (K.t, V.t) Core.Std.Hashtbl.t -> t
          val find : t -> K.t -> V.t option
          val mem : t -> K.t -> bool
          val iter : t -> f:(key:K.t -> data:V.t -> unit) -> unit
          val bin_t : t Core.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core.Std.Bin_prot.Read_ml.reader
          val bin_read_t_ : t Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            (int -> t) Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core.Std.Bin_prot.Write_ml.writer
          val bin_write_t_ : t Core.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_key : K.t Core.Std.Bin_prot.Type_class.t
          val bin_read_key : K.t Core.Std.Bin_prot.Read_ml.reader
          val bin_read_key_ : K.t Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_key__ :
            (int -> K.t) Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_key : K.t Core.Std.Bin_prot.Type_class.reader
          val bin_size_key : K.t Core.Std.Bin_prot.Size.sizer
          val bin_write_key : K.t Core.Std.Bin_prot.Write_ml.writer
          val bin_write_key_ : K.t Core.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_key : K.t Core.Std.Bin_prot.Type_class.writer
          val key_of_sexp : Sexplib.Sexp.t -> K.t
          val sexp_of_key : K.t -> Sexplib.Sexp.t
          val bin_value : V.t Core.Std.Bin_prot.Type_class.t
          val bin_read_value : V.t Core.Std.Bin_prot.Read_ml.reader
          val bin_read_value_ : V.t Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_value__ :
            (int -> V.t) Core.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_value : V.t Core.Std.Bin_prot.Type_class.reader
          val bin_size_value : V.t Core.Std.Bin_prot.Size.sizer
          val bin_write_value : V.t Core.Std.Bin_prot.Write_ml.writer
          val bin_write_value_ : V.t Core.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_value : V.t Core.Std.Bin_prot.Type_class.writer
          val value_of_sexp : Sexplib.Sexp.t -> V.t
          val sexp_of_value : V.t -> Sexplib.Sexp.t
        end
end