sig
  type 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 : Core_gc.Stat.t -> int
  val top_heap_words : Core_gc.Stat.t -> int
  val compactions : Core_gc.Stat.t -> int
  val fragments : Core_gc.Stat.t -> int
  val largest_free : Core_gc.Stat.t -> int
  val free_blocks : Core_gc.Stat.t -> int
  val free_words : Core_gc.Stat.t -> int
  val live_blocks : Core_gc.Stat.t -> int
  val live_words : Core_gc.Stat.t -> int
  val heap_chunks : Core_gc.Stat.t -> int
  val heap_words : Core_gc.Stat.t -> int
  val major_collections : Core_gc.Stat.t -> int
  val minor_collections : Core_gc.Stat.t -> int
  val major_words : Core_gc.Stat.t -> float
  val promoted_words : Core_gc.Stat.t -> float
  val minor_words : Core_gc.Stat.t -> float
  module Fields :
    sig
      val names : string list
      val stack_size : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val top_heap_words : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val compactions : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val fragments : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val largest_free : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val free_blocks : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val free_words : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val live_blocks : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val live_words : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val heap_chunks : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val heap_words : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val major_collections : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val minor_collections : (Core_gc.Stat.t, int) Fieldslib.Field.t
      val major_words : (Core_gc.Stat.t, float) Fieldslib.Field.t
      val promoted_words : (Core_gc.Stat.t, float) Fieldslib.Field.t
      val minor_words : (Core_gc.Stat.t, float) Fieldslib.Field.t
      val fold :
        init:'acc__ ->
        minor_words:('acc__ ->
                     (Core_gc.Stat.t, float) Fieldslib.Field.t -> 'acc__) ->
        promoted_words:('acc__ ->
                        (Core_gc.Stat.t, float) Fieldslib.Field.t -> 'acc__) ->
        major_words:('acc__ ->
                     (Core_gc.Stat.t, float) Fieldslib.Field.t -> 'acc__) ->
        minor_collections:('acc__ ->
                           (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        major_collections:('acc__ ->
                           (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        heap_words:('acc__ ->
                    (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        heap_chunks:('acc__ ->
                     (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        live_words:('acc__ ->
                    (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        live_blocks:('acc__ ->
                     (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        free_words:('acc__ ->
                    (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        free_blocks:('acc__ ->
                     (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        largest_free:('acc__ ->
                      (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        fragments:('acc__ ->
                   (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        compactions:('acc__ ->
                     (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        top_heap_words:('acc__ ->
                        (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        stack_size:('acc__ ->
                    (Core_gc.Stat.t, int) Fieldslib.Field.t -> 'acc__) ->
        'acc__
      val make_creator :
        minor_words:((Core_gc.Stat.t, float) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> float) * 'compile_acc__) ->
        promoted_words:((Core_gc.Stat.t, float) Fieldslib.Field.t ->
                        'compile_acc__ ->
                        ('input__ -> float) * 'compile_acc__) ->
        major_words:((Core_gc.Stat.t, float) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> float) * 'compile_acc__) ->
        minor_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                           'compile_acc__ ->
                           ('input__ -> int) * 'compile_acc__) ->
        major_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                           'compile_acc__ ->
                           ('input__ -> int) * 'compile_acc__) ->
        heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        heap_chunks:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        live_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        live_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        free_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        free_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        largest_free:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                      'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        fragments:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                   'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        compactions:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                     'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        top_heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        stack_size:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                    'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
        'compile_acc__ -> ('input__ -> Core_gc.Stat.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 -> Core_gc.Stat.t
      val map :
        minor_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> float) ->
        promoted_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> float) ->
        major_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> float) ->
        minor_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        major_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        heap_chunks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        live_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        live_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        free_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        free_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        largest_free:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        fragments:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        compactions:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        top_heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        stack_size:((Core_gc.Stat.t, int) Fieldslib.Field.t -> int) ->
        Core_gc.Stat.t
      val iter :
        minor_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> unit) ->
        promoted_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> unit) ->
        major_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> unit) ->
        minor_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        major_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        heap_chunks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        live_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        live_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        free_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        free_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        largest_free:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        fragments:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        compactions:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        top_heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) ->
        stack_size:((Core_gc.Stat.t, int) Fieldslib.Field.t -> unit) -> unit
      val for_all :
        minor_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> bool) ->
        promoted_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> bool) ->
        major_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> bool) ->
        minor_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        major_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        heap_chunks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        live_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        live_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        free_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        free_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        largest_free:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        fragments:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        compactions:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        top_heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        stack_size:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) -> bool
      val exists :
        minor_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> bool) ->
        promoted_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> bool) ->
        major_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> bool) ->
        minor_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        major_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        heap_chunks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        live_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        live_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        free_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        free_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        largest_free:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        fragments:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        compactions:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        top_heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) ->
        stack_size:((Core_gc.Stat.t, int) Fieldslib.Field.t -> bool) -> bool
      val to_list :
        minor_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> 'elem__) ->
        promoted_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> 'elem__) ->
        major_words:((Core_gc.Stat.t, float) Fieldslib.Field.t -> 'elem__) ->
        minor_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        major_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        heap_chunks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        live_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        live_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        free_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        free_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        largest_free:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        fragments:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        compactions:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        top_heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        stack_size:((Core_gc.Stat.t, int) Fieldslib.Field.t -> 'elem__) ->
        'elem__ list
      val map_poly :
        ([< `Read | `Set_and_create ], Core_gc.Stat.t, 'x0)
        Fieldslib.Field.user -> 'x0 list
      module Direct :
        sig
          val iter :
            Core_gc.Stat.t ->
            minor_words:((Core_gc.Stat.t, float) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> float -> unit) ->
            promoted_words:((Core_gc.Stat.t, float) Fieldslib.Field.t ->
                            Core_gc.Stat.t -> float -> unit) ->
            major_words:((Core_gc.Stat.t, float) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> float -> unit) ->
            minor_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                               Core_gc.Stat.t -> int -> unit) ->
            major_collections:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                               Core_gc.Stat.t -> int -> unit) ->
            heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> unit) ->
            heap_chunks:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> unit) ->
            live_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> unit) ->
            live_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> unit) ->
            free_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> unit) ->
            free_blocks:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> unit) ->
            largest_free:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                          Core_gc.Stat.t -> int -> unit) ->
            fragments:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                       Core_gc.Stat.t -> int -> unit) ->
            compactions:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> unit) ->
            top_heap_words:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                            Core_gc.Stat.t -> int -> unit) ->
            stack_size:((Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> unit) ->
            unit
          val fold :
            Core_gc.Stat.t ->
            init:'acc__ ->
            minor_words:('acc__ ->
                         (Core_gc.Stat.t, float) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> float -> 'acc__) ->
            promoted_words:('acc__ ->
                            (Core_gc.Stat.t, float) Fieldslib.Field.t ->
                            Core_gc.Stat.t -> float -> 'acc__) ->
            major_words:('acc__ ->
                         (Core_gc.Stat.t, float) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> float -> 'acc__) ->
            minor_collections:('acc__ ->
                               (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                               Core_gc.Stat.t -> int -> 'acc__) ->
            major_collections:('acc__ ->
                               (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                               Core_gc.Stat.t -> int -> 'acc__) ->
            heap_words:('acc__ ->
                        (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> 'acc__) ->
            heap_chunks:('acc__ ->
                         (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> 'acc__) ->
            live_words:('acc__ ->
                        (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> 'acc__) ->
            live_blocks:('acc__ ->
                         (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> 'acc__) ->
            free_words:('acc__ ->
                        (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> 'acc__) ->
            free_blocks:('acc__ ->
                         (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> 'acc__) ->
            largest_free:('acc__ ->
                          (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                          Core_gc.Stat.t -> int -> 'acc__) ->
            fragments:('acc__ ->
                       (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                       Core_gc.Stat.t -> int -> 'acc__) ->
            compactions:('acc__ ->
                         (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                         Core_gc.Stat.t -> int -> 'acc__) ->
            top_heap_words:('acc__ ->
                            (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                            Core_gc.Stat.t -> int -> 'acc__) ->
            stack_size:('acc__ ->
                        (Core_gc.Stat.t, int) Fieldslib.Field.t ->
                        Core_gc.Stat.t -> int -> 'acc__) ->
            'acc__
          val set_all_mutable_fields : Core_gc.Stat.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
  val comparator : (t, comparator_witness) Comparator.comparator
  val validate_lbound : min:t Comparable_intf.bound -> t Validate.check
  val validate_ubound : max:t Comparable_intf.bound -> t Validate.check
  val validate_bound :
    min:t Comparable_intf.bound ->
    max:t Comparable_intf.bound -> t Validate.check
  module Map :
    sig
      module Key :
        sig
          type t = t
          type comparator_witness = comparator_witness
          val comparator : (t, comparator_witness) Comparator.comparator
        end
      module Tree :
        sig
          type 'a t = (Key.t, 'a, Key.comparator_witness) 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 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 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) ->
            'Validate.check -> 'a t 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 ])
            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) 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_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 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 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) -> 'Validate.check -> 'a t 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 ])
        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) 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) 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_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 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) Either.t 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 Sequence.t
          val to_map :
            t ->
            f:(Elt.t -> 'data) ->
            (Elt.t, 'data, Elt.comparator_witness) 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 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_set.Tree.t -> f:('-> Elt.t) -> t
          val filter_map :
            ('a, 'b) 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_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_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 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) Either.t 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 Sequence.t
      val to_map :
        t ->
        f:(Elt.t -> 'data) ->
        (Elt.t, 'data, Elt.comparator_witness) 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 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_set.t -> f:('-> Elt.t) -> t
      val filter_map : ('a, 'b) 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_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 -> Core_gc.Stat.t
  val sexp_of_t : Core_gc.Stat.t -> Sexplib.Sexp.t
  val bin_t : Core_gc.Stat.t Bin_prot.Type_class.t
  val bin_read_t : Core_gc.Stat.t Bin_prot.Read.reader
  val __bin_read_t__ : (int -> Core_gc.Stat.t) Bin_prot.Read.reader
  val bin_reader_t : Core_gc.Stat.t Bin_prot.Type_class.reader
  val bin_size_t : Core_gc.Stat.t Bin_prot.Size.sizer
  val bin_write_t : Core_gc.Stat.t Bin_prot.Write.writer
  val bin_writer_t : Core_gc.Stat.t Bin_prot.Type_class.writer
end