sig
  module Stat :
    sig
      type t =
        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 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 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 map_poly : (t, 'x0) Fieldslib.Field.user -> 'x0 list
          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
          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__
            end
        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_ml.reader
      val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
      val bin_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_ml.writer
      val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t : t Bin_prot.Type_class.writer
    end
  type stat = Stat.t
  module Control :
    sig
      type t =
        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 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 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 map_poly : (t, 'x0) Fieldslib.Field.user -> 'x0 list
          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
          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__
            end
        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_ml.reader
      val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
      val bin_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_ml.writer
      val bin_write_t_ : t Bin_prot.Unsafe_write_c.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 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 finalise : ('a -> unit) -> 'a -> unit
  val finalise_release : unit -> unit
  type alarm = Gc.alarm
  val create_alarm : (unit -> unit) -> alarm
  val delete_alarm : alarm -> 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
  val ounit_tests : unit -> OUnit.test
end