sig
  module Stat :
    sig
      type t =
        Core_kernel.Core_gc.Stat.t = {
        minor_words : float;
        promoted_words : float;
        major_words : float;
        minor_collections : int;
        major_collections : int;
        heap_words : int;
        heap_chunks : int;
        live_words : int;
        live_blocks : int;
        free_words : int;
        free_blocks : int;
        largest_free : int;
        fragments : int;
        compactions : int;
        top_heap_words : int;
        stack_size : int;
      }
      val stack_size : t -> int
      val top_heap_words : t -> int
      val compactions : t -> int
      val fragments : t -> int
      val largest_free : t -> int
      val free_blocks : t -> int
      val free_words : t -> int
      val live_blocks : t -> int
      val live_words : t -> int
      val heap_chunks : t -> int
      val heap_words : t -> int
      val major_collections : t -> int
      val minor_collections : t -> int
      val major_words : t -> float
      val promoted_words : t -> float
      val minor_words : t -> float
      module Fields :
        sig
          val names : string list
          val stack_size : (t, int) Fieldslib.Field.t
          val top_heap_words : (t, int) Fieldslib.Field.t
          val compactions : (t, int) Fieldslib.Field.t
          val fragments : (t, int) Fieldslib.Field.t
          val largest_free : (t, int) Fieldslib.Field.t
          val free_blocks : (t, int) Fieldslib.Field.t
          val free_words : (t, int) Fieldslib.Field.t
          val live_blocks : (t, int) Fieldslib.Field.t
          val live_words : (t, int) Fieldslib.Field.t
          val heap_chunks : (t, int) Fieldslib.Field.t
          val heap_words : (t, int) Fieldslib.Field.t
          val major_collections : (t, int) Fieldslib.Field.t
          val minor_collections : (t, int) Fieldslib.Field.t
          val major_words : (t, float) Fieldslib.Field.t
          val promoted_words : (t, float) Fieldslib.Field.t
          val minor_words : (t, float) Fieldslib.Field.t
          val fold :
            init:'acc__ ->
            minor_words:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
            promoted_words:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
            major_words:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
            minor_collections:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            major_collections:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            heap_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            heap_chunks:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            live_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            live_blocks:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            free_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            free_blocks:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            largest_free:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            fragments:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            compactions:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            top_heap_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            stack_size:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            'acc__
          val make_creator :
            minor_words:((t, float) Fieldslib.Field.t ->
                         'compile_acc__ ->
                         ('input__ -> float) * 'compile_acc__) ->
            promoted_words:((t, float) Fieldslib.Field.t ->
                            'compile_acc__ ->
                            ('input__ -> float) * 'compile_acc__) ->
            major_words:((t, float) Fieldslib.Field.t ->
                         'compile_acc__ ->
                         ('input__ -> float) * 'compile_acc__) ->
            minor_collections:((t, int) Fieldslib.Field.t ->
                               'compile_acc__ ->
                               ('input__ -> int) * 'compile_acc__) ->
            major_collections:((t, int) Fieldslib.Field.t ->
                               'compile_acc__ ->
                               ('input__ -> int) * 'compile_acc__) ->
            heap_words:((t, int) Fieldslib.Field.t ->
                        'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            heap_chunks:((t, int) Fieldslib.Field.t ->
                         'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            live_words:((t, int) Fieldslib.Field.t ->
                        'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            live_blocks:((t, int) Fieldslib.Field.t ->
                         'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            free_words:((t, int) Fieldslib.Field.t ->
                        'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            free_blocks:((t, int) Fieldslib.Field.t ->
                         'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            largest_free:((t, int) Fieldslib.Field.t ->
                          'compile_acc__ ->
                          ('input__ -> int) * 'compile_acc__) ->
            fragments:((t, int) Fieldslib.Field.t ->
                       'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            compactions:((t, int) Fieldslib.Field.t ->
                         'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            top_heap_words:((t, int) Fieldslib.Field.t ->
                            'compile_acc__ ->
                            ('input__ -> int) * 'compile_acc__) ->
            stack_size:((t, int) Fieldslib.Field.t ->
                        'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            'compile_acc__ -> ('input__ -> t) * 'compile_acc__
          val create :
            minor_words:float ->
            promoted_words:float ->
            major_words:float ->
            minor_collections:int ->
            major_collections:int ->
            heap_words:int ->
            heap_chunks:int ->
            live_words:int ->
            live_blocks:int ->
            free_words:int ->
            free_blocks:int ->
            largest_free:int ->
            fragments:int ->
            compactions:int -> top_heap_words:int -> stack_size:int -> t
          val map :
            minor_words:((t, float) Fieldslib.Field.t -> float) ->
            promoted_words:((t, float) Fieldslib.Field.t -> float) ->
            major_words:((t, float) Fieldslib.Field.t -> float) ->
            minor_collections:((t, int) Fieldslib.Field.t -> int) ->
            major_collections:((t, int) Fieldslib.Field.t -> int) ->
            heap_words:((t, int) Fieldslib.Field.t -> int) ->
            heap_chunks:((t, int) Fieldslib.Field.t -> int) ->
            live_words:((t, int) Fieldslib.Field.t -> int) ->
            live_blocks:((t, int) Fieldslib.Field.t -> int) ->
            free_words:((t, int) Fieldslib.Field.t -> int) ->
            free_blocks:((t, int) Fieldslib.Field.t -> int) ->
            largest_free:((t, int) Fieldslib.Field.t -> int) ->
            fragments:((t, int) Fieldslib.Field.t -> int) ->
            compactions:((t, int) Fieldslib.Field.t -> int) ->
            top_heap_words:((t, int) Fieldslib.Field.t -> int) ->
            stack_size:((t, int) Fieldslib.Field.t -> int) -> t
          val iter :
            minor_words:((t, float) Fieldslib.Field.t -> unit) ->
            promoted_words:((t, float) Fieldslib.Field.t -> unit) ->
            major_words:((t, float) Fieldslib.Field.t -> unit) ->
            minor_collections:((t, int) Fieldslib.Field.t -> unit) ->
            major_collections:((t, int) Fieldslib.Field.t -> unit) ->
            heap_words:((t, int) Fieldslib.Field.t -> unit) ->
            heap_chunks:((t, int) Fieldslib.Field.t -> unit) ->
            live_words:((t, int) Fieldslib.Field.t -> unit) ->
            live_blocks:((t, int) Fieldslib.Field.t -> unit) ->
            free_words:((t, int) Fieldslib.Field.t -> unit) ->
            free_blocks:((t, int) Fieldslib.Field.t -> unit) ->
            largest_free:((t, int) Fieldslib.Field.t -> unit) ->
            fragments:((t, int) Fieldslib.Field.t -> unit) ->
            compactions:((t, int) Fieldslib.Field.t -> unit) ->
            top_heap_words:((t, int) Fieldslib.Field.t -> unit) ->
            stack_size:((t, int) Fieldslib.Field.t -> unit) -> unit
          val for_all :
            minor_words:((t, float) Fieldslib.Field.t -> bool) ->
            promoted_words:((t, float) Fieldslib.Field.t -> bool) ->
            major_words:((t, float) Fieldslib.Field.t -> bool) ->
            minor_collections:((t, int) Fieldslib.Field.t -> bool) ->
            major_collections:((t, int) Fieldslib.Field.t -> bool) ->
            heap_words:((t, int) Fieldslib.Field.t -> bool) ->
            heap_chunks:((t, int) Fieldslib.Field.t -> bool) ->
            live_words:((t, int) Fieldslib.Field.t -> bool) ->
            live_blocks:((t, int) Fieldslib.Field.t -> bool) ->
            free_words:((t, int) Fieldslib.Field.t -> bool) ->
            free_blocks:((t, int) Fieldslib.Field.t -> bool) ->
            largest_free:((t, int) Fieldslib.Field.t -> bool) ->
            fragments:((t, int) Fieldslib.Field.t -> bool) ->
            compactions:((t, int) Fieldslib.Field.t -> bool) ->
            top_heap_words:((t, int) Fieldslib.Field.t -> bool) ->
            stack_size:((t, int) Fieldslib.Field.t -> bool) -> bool
          val exists :
            minor_words:((t, float) Fieldslib.Field.t -> bool) ->
            promoted_words:((t, float) Fieldslib.Field.t -> bool) ->
            major_words:((t, float) Fieldslib.Field.t -> bool) ->
            minor_collections:((t, int) Fieldslib.Field.t -> bool) ->
            major_collections:((t, int) Fieldslib.Field.t -> bool) ->
            heap_words:((t, int) Fieldslib.Field.t -> bool) ->
            heap_chunks:((t, int) Fieldslib.Field.t -> bool) ->
            live_words:((t, int) Fieldslib.Field.t -> bool) ->
            live_blocks:((t, int) Fieldslib.Field.t -> bool) ->
            free_words:((t, int) Fieldslib.Field.t -> bool) ->
            free_blocks:((t, int) Fieldslib.Field.t -> bool) ->
            largest_free:((t, int) Fieldslib.Field.t -> bool) ->
            fragments:((t, int) Fieldslib.Field.t -> bool) ->
            compactions:((t, int) Fieldslib.Field.t -> bool) ->
            top_heap_words:((t, int) Fieldslib.Field.t -> bool) ->
            stack_size:((t, int) Fieldslib.Field.t -> bool) -> bool
          val to_list :
            minor_words:((t, float) Fieldslib.Field.t -> 'elem__) ->
            promoted_words:((t, float) Fieldslib.Field.t -> 'elem__) ->
            major_words:((t, float) Fieldslib.Field.t -> 'elem__) ->
            minor_collections:((t, int) Fieldslib.Field.t -> 'elem__) ->
            major_collections:((t, int) Fieldslib.Field.t -> 'elem__) ->
            heap_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
            heap_chunks:((t, int) Fieldslib.Field.t -> 'elem__) ->
            live_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
            live_blocks:((t, int) Fieldslib.Field.t -> 'elem__) ->
            free_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
            free_blocks:((t, int) Fieldslib.Field.t -> 'elem__) ->
            largest_free:((t, int) Fieldslib.Field.t -> 'elem__) ->
            fragments:((t, int) Fieldslib.Field.t -> 'elem__) ->
            compactions:((t, int) Fieldslib.Field.t -> 'elem__) ->
            top_heap_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
            stack_size:((t, int) Fieldslib.Field.t -> 'elem__) ->
            'elem__ list
          val map_poly :
            ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
            'x0 list
          module Direct :
            sig
              val iter :
                t ->
                minor_words:((t, float) Fieldslib.Field.t ->
                             t -> float -> unit) ->
                promoted_words:((t, float) Fieldslib.Field.t ->
                                t -> float -> unit) ->
                major_words:((t, float) Fieldslib.Field.t ->
                             t -> float -> unit) ->
                minor_collections:((t, int) Fieldslib.Field.t ->
                                   t -> int -> unit) ->
                major_collections:((t, int) Fieldslib.Field.t ->
                                   t -> int -> unit) ->
                heap_words:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                heap_chunks:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                live_words:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                live_blocks:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                free_words:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                free_blocks:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                largest_free:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                fragments:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                compactions:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                top_heap_words:((t, int) Fieldslib.Field.t ->
                                t -> int -> unit) ->
                stack_size:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                unit
              val fold :
                t ->
                init:'acc__ ->
                minor_words:('acc__ ->
                             (t, float) Fieldslib.Field.t ->
                             t -> float -> 'acc__) ->
                promoted_words:('acc__ ->
                                (t, float) Fieldslib.Field.t ->
                                t -> float -> 'acc__) ->
                major_words:('acc__ ->
                             (t, float) Fieldslib.Field.t ->
                             t -> float -> 'acc__) ->
                minor_collections:('acc__ ->
                                   (t, int) Fieldslib.Field.t ->
                                   t -> int -> 'acc__) ->
                major_collections:('acc__ ->
                                   (t, int) Fieldslib.Field.t ->
                                   t -> int -> 'acc__) ->
                heap_words:('acc__ ->
                            (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                heap_chunks:('acc__ ->
                             (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                live_words:('acc__ ->
                            (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                live_blocks:('acc__ ->
                             (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                free_words:('acc__ ->
                            (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                free_blocks:('acc__ ->
                             (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                largest_free:('acc__ ->
                              (t, int) Fieldslib.Field.t ->
                              t -> int -> 'acc__) ->
                fragments:('acc__ ->
                           (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                compactions:('acc__ ->
                             (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                top_heap_words:('acc__ ->
                                (t, int) Fieldslib.Field.t ->
                                t -> int -> 'acc__) ->
                stack_size:('acc__ ->
                            (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                'acc__
              val set_all_mutable_fields : t -> unit
            end
        end
      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_witness = Core_kernel.Core_gc.Stat.comparator_witness
      val comparator :
        (t, comparator_witness) Core_kernel.Comparator.comparator
      val validate_lbound :
        min:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_ubound :
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_bound :
        min:t Core_kernel.Comparable_intf.bound ->
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      module Map :
        sig
          module Key :
            sig
              type t = t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator_witness)
                  Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_tree : 'a t -> 'a t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist : 'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t * [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
                Core_kernel.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Core_kernel.Sequence.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error :
            (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array :
            (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_tree : 'Tree.t -> 'a t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist : 'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> string) ->
            'Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t * [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
            Core_kernel.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Core_kernel.Sequence.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel.Comparator.comparator
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          module Tree :
            sig
              type t =
                  (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Core_kernel.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t ->
                t ->
                (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, Elt.comparator_witness)
                Core_kernel.Core_set_intf.Map.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_map_keys :
                (Elt.t, 'a, Elt.comparator_witness)
                Core_kernel.Core_set_intf.Map.t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
            end
          type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Core_kernel.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t ->
            t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, Elt.comparator_witness)
            Core_kernel.Core_set_intf.Map.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_map_keys :
            (Elt.t, 'a, Elt.comparator_witness)
            Core_kernel.Core_set_intf.Map.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
        end
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Bin_prot.Type_class.t
      val bin_read_t : t Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
      val bin_reader_t : t Bin_prot.Type_class.reader
      val bin_size_t : t Bin_prot.Size.sizer
      val bin_write_t : t Bin_prot.Write.writer
      val bin_writer_t : t Bin_prot.Type_class.writer
    end
  type stat = Stat.t
  module Control :
    sig
      type t =
        Core_kernel.Core_gc.Control.t = {
        mutable minor_heap_size : int;
        mutable major_heap_increment : int;
        mutable space_overhead : int;
        mutable verbose : int;
        mutable max_overhead : int;
        mutable stack_limit : int;
        mutable allocation_policy : int;
      }
      val allocation_policy : t -> int
      val set_allocation_policy : t -> int -> unit
      val stack_limit : t -> int
      val set_stack_limit : t -> int -> unit
      val max_overhead : t -> int
      val set_max_overhead : t -> int -> unit
      val verbose : t -> int
      val set_verbose : t -> int -> unit
      val space_overhead : t -> int
      val set_space_overhead : t -> int -> unit
      val major_heap_increment : t -> int
      val set_major_heap_increment : t -> int -> unit
      val minor_heap_size : t -> int
      val set_minor_heap_size : t -> int -> unit
      module Fields :
        sig
          val names : string list
          val allocation_policy : (t, int) Fieldslib.Field.t
          val stack_limit : (t, int) Fieldslib.Field.t
          val max_overhead : (t, int) Fieldslib.Field.t
          val verbose : (t, int) Fieldslib.Field.t
          val space_overhead : (t, int) Fieldslib.Field.t
          val major_heap_increment : (t, int) Fieldslib.Field.t
          val minor_heap_size : (t, int) Fieldslib.Field.t
          val fold :
            init:'acc__ ->
            minor_heap_size:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            major_heap_increment:('acc__ ->
                                  (t, int) Fieldslib.Field.t -> 'acc__) ->
            space_overhead:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            verbose:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            max_overhead:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            stack_limit:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            allocation_policy:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
            'acc__
          val make_creator :
            minor_heap_size:((t, int) Fieldslib.Field.t ->
                             'compile_acc__ ->
                             ('input__ -> int) * 'compile_acc__) ->
            major_heap_increment:((t, int) Fieldslib.Field.t ->
                                  'compile_acc__ ->
                                  ('input__ -> int) * 'compile_acc__) ->
            space_overhead:((t, int) Fieldslib.Field.t ->
                            'compile_acc__ ->
                            ('input__ -> int) * 'compile_acc__) ->
            verbose:((t, int) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            max_overhead:((t, int) Fieldslib.Field.t ->
                          'compile_acc__ ->
                          ('input__ -> int) * 'compile_acc__) ->
            stack_limit:((t, int) Fieldslib.Field.t ->
                         'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
            allocation_policy:((t, int) Fieldslib.Field.t ->
                               'compile_acc__ ->
                               ('input__ -> int) * 'compile_acc__) ->
            'compile_acc__ -> ('input__ -> t) * 'compile_acc__
          val create :
            minor_heap_size:int ->
            major_heap_increment:int ->
            space_overhead:int ->
            verbose:int ->
            max_overhead:int -> stack_limit:int -> allocation_policy:int -> t
          val map :
            minor_heap_size:((t, int) Fieldslib.Field.t -> int) ->
            major_heap_increment:((t, int) Fieldslib.Field.t -> int) ->
            space_overhead:((t, int) Fieldslib.Field.t -> int) ->
            verbose:((t, int) Fieldslib.Field.t -> int) ->
            max_overhead:((t, int) Fieldslib.Field.t -> int) ->
            stack_limit:((t, int) Fieldslib.Field.t -> int) ->
            allocation_policy:((t, int) Fieldslib.Field.t -> int) -> t
          val iter :
            minor_heap_size:((t, int) Fieldslib.Field.t -> unit) ->
            major_heap_increment:((t, int) Fieldslib.Field.t -> unit) ->
            space_overhead:((t, int) Fieldslib.Field.t -> unit) ->
            verbose:((t, int) Fieldslib.Field.t -> unit) ->
            max_overhead:((t, int) Fieldslib.Field.t -> unit) ->
            stack_limit:((t, int) Fieldslib.Field.t -> unit) ->
            allocation_policy:((t, int) Fieldslib.Field.t -> unit) -> unit
          val for_all :
            minor_heap_size:((t, int) Fieldslib.Field.t -> bool) ->
            major_heap_increment:((t, int) Fieldslib.Field.t -> bool) ->
            space_overhead:((t, int) Fieldslib.Field.t -> bool) ->
            verbose:((t, int) Fieldslib.Field.t -> bool) ->
            max_overhead:((t, int) Fieldslib.Field.t -> bool) ->
            stack_limit:((t, int) Fieldslib.Field.t -> bool) ->
            allocation_policy:((t, int) Fieldslib.Field.t -> bool) -> bool
          val exists :
            minor_heap_size:((t, int) Fieldslib.Field.t -> bool) ->
            major_heap_increment:((t, int) Fieldslib.Field.t -> bool) ->
            space_overhead:((t, int) Fieldslib.Field.t -> bool) ->
            verbose:((t, int) Fieldslib.Field.t -> bool) ->
            max_overhead:((t, int) Fieldslib.Field.t -> bool) ->
            stack_limit:((t, int) Fieldslib.Field.t -> bool) ->
            allocation_policy:((t, int) Fieldslib.Field.t -> bool) -> bool
          val to_list :
            minor_heap_size:((t, int) Fieldslib.Field.t -> 'elem__) ->
            major_heap_increment:((t, int) Fieldslib.Field.t -> 'elem__) ->
            space_overhead:((t, int) Fieldslib.Field.t -> 'elem__) ->
            verbose:((t, int) Fieldslib.Field.t -> 'elem__) ->
            max_overhead:((t, int) Fieldslib.Field.t -> 'elem__) ->
            stack_limit:((t, int) Fieldslib.Field.t -> 'elem__) ->
            allocation_policy:((t, int) Fieldslib.Field.t -> 'elem__) ->
            'elem__ list
          val map_poly :
            ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
            'x0 list
          module Direct :
            sig
              val iter :
                t ->
                minor_heap_size:((t, int) Fieldslib.Field.t ->
                                 t -> int -> unit) ->
                major_heap_increment:((t, int) Fieldslib.Field.t ->
                                      t -> int -> unit) ->
                space_overhead:((t, int) Fieldslib.Field.t ->
                                t -> int -> unit) ->
                verbose:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                max_overhead:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                stack_limit:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                allocation_policy:((t, int) Fieldslib.Field.t ->
                                   t -> int -> unit) ->
                unit
              val fold :
                t ->
                init:'acc__ ->
                minor_heap_size:('acc__ ->
                                 (t, int) Fieldslib.Field.t ->
                                 t -> int -> 'acc__) ->
                major_heap_increment:('acc__ ->
                                      (t, int) Fieldslib.Field.t ->
                                      t -> int -> 'acc__) ->
                space_overhead:('acc__ ->
                                (t, int) Fieldslib.Field.t ->
                                t -> int -> 'acc__) ->
                verbose:('acc__ ->
                         (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                max_overhead:('acc__ ->
                              (t, int) Fieldslib.Field.t ->
                              t -> int -> 'acc__) ->
                stack_limit:('acc__ ->
                             (t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
                allocation_policy:('acc__ ->
                                   (t, int) Fieldslib.Field.t ->
                                   t -> int -> 'acc__) ->
                'acc__
              val set_all_mutable_fields :
                t ->
                minor_heap_size:int ->
                major_heap_increment:int ->
                space_overhead:int ->
                verbose:int ->
                max_overhead:int ->
                stack_limit:int -> allocation_policy:int -> unit
            end
        end
      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_witness =
          Core_kernel.Core_gc.Control.comparator_witness
      val comparator :
        (t, comparator_witness) Core_kernel.Comparator.comparator
      val validate_lbound :
        min:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_ubound :
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_bound :
        min:t Core_kernel.Comparable_intf.bound ->
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      module Map :
        sig
          module Key :
            sig
              type t = t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel.Comparator.comparator
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator_witness)
                  Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_tree : 'a t -> 'a t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist : 'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t * [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
                Core_kernel.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Core_kernel.Sequence.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t =
              (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> '-> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_or_error :
            (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
          val of_sorted_array :
            (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_tree : 'Tree.t -> 'a t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add : 'a t -> key:Key.t -> data:'-> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
          val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * '| `Left of '| `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('-> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
          val fold :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val fold_right :
            'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
          val filter_map : 'a t -> f:('-> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
          val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist : 'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> string) ->
            'Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * '| `Left of '| `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('-> '-> bool) ->
            (Key.t * [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
            Core_kernel.Sequence.t
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('-> bool) -> bool
          val exists : 'a t -> f:('-> bool) -> bool
          val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val closest_key :
            'a t ->
            [ `Greater_or_equal_to
            | `Greater_than
            | `Less_or_equal_to
            | `Less_than ] -> Key.t -> (Key.t * 'a) option
          val nth : 'a t -> int -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'Tree.t
          val to_sequence :
            ?order:[ `Decreasing_key | `Increasing_key ] ->
            ?keys_greater_or_equal_to:Key.t ->
            ?keys_less_or_equal_to:Key.t ->
            'a t -> (Key.t * 'a) Core_kernel.Sequence.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              type comparator_witness = comparator_witness
              val comparator :
                (t, comparator_witness) Core_kernel.Comparator.comparator
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          module Tree :
            sig
              type t =
                  (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Core_kernel.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t ->
                t ->
                (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, Elt.comparator_witness)
                Core_kernel.Core_set_intf.Map.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('-> Elt.t option) -> t
              val of_tree : t -> t
              val of_map_keys :
                (Elt.t, 'a, Elt.comparator_witness)
                Core_kernel.Core_set_intf.Map.t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
            end
          type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val sum :
            (module Core_kernel.Commutative_group.S with type t = 'sum) ->
            t -> f:(Elt.t -> 'sum) -> 'sum
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val symmetric_diff :
            t ->
            t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'->
            f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * Elt.t option * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val to_sequence :
            ?order:[ `Decreasing | `Increasing ] ->
            ?greater_or_equal_to:Elt.t ->
            ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, Elt.comparator_witness)
            Core_kernel.Core_set_intf.Map.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val of_map_keys :
            (Elt.t, 'a, Elt.comparator_witness)
            Core_kernel.Core_set_intf.Map.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
        end
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Bin_prot.Type_class.t
      val bin_read_t : t Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
      val bin_reader_t : t Bin_prot.Type_class.reader
      val bin_size_t : t Bin_prot.Size.sizer
      val bin_write_t : t Bin_prot.Write.writer
      val bin_writer_t : t Bin_prot.Type_class.writer
    end
  type control = Control.t
  external stat : unit -> stat = "caml_gc_stat"
  external quick_stat : unit -> stat = "caml_gc_quick_stat"
  external counters : unit -> float * float * float = "caml_gc_counters"
  external minor_words : unit -> int = "core_kernel_gc_minor_words"
  external major_words : unit -> int = "core_kernel_gc_major_words" "noalloc"
  external promoted_words : unit -> int = "core_kernel_gc_promoted_words"
    "noalloc"
  external minor_collections : unit -> int
    = "core_kernel_gc_minor_collections" "noalloc"
  external major_collections : unit -> int
    = "core_kernel_gc_major_collections" "noalloc"
  external heap_words : unit -> int = "core_kernel_gc_heap_words" "noalloc"
  external heap_chunks : unit -> int = "core_kernel_gc_heap_chunks" "noalloc"
  external compactions : unit -> int = "core_kernel_gc_compactions" "noalloc"
  external top_heap_words : unit -> int = "core_kernel_gc_top_heap_words"
    "noalloc"
  external major_plus_minor_words : unit -> int
    = "core_kernel_gc_major_plus_minor_words"
  external get : unit -> control = "caml_gc_get"
  external set : control -> unit = "caml_gc_set"
  external minor : unit -> unit = "caml_gc_minor"
  external major_slice : int -> int = "caml_gc_major_slice"
  external major : unit -> unit = "caml_gc_major"
  external full_major : unit -> unit = "caml_gc_full_major"
  external compact : unit -> unit = "caml_gc_compaction"
  val print_stat : out_channel -> unit
  val allocated_bytes : unit -> float
  val keep_alive : '-> unit
  val tune :
    ?logger:(string -> unit) ->
    ?minor_heap_size:int ->
    ?major_heap_increment:int ->
    ?space_overhead:int ->
    ?verbose:int ->
    ?max_overhead:int ->
    ?stack_limit:int -> ?allocation_policy:int -> unit -> unit
  module Allocation_policy :
    sig
      type t = Core_kernel.Core_gc.Allocation_policy.t = Next_fit | First_fit
    end
  val disable_compaction :
    ?logger:(string -> unit) ->
    allocation_policy:[ `Don't_change | `Set_to of Allocation_policy.t ] ->
    unit -> unit
  module Expert :
    sig
      val add_finalizer :
        'Core_kernel.Heap_block.t ->
        ('Core_kernel.Heap_block.t -> unit) -> unit
      val add_finalizer_exn : '-> ('-> unit) -> unit
      val finalize_release : unit -> unit
      module Alarm :
        sig
          type t = Core_kernel.Core_gc.Expert.Alarm.t
          val create : (unit -> unit) -> t
          val delete : t -> unit
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
    end
  val without_compactions :
    ?logger:(string -> unit) -> f:('-> 'b) -> '-> 'b
end