sig
  module Stream :
    sig
      type 'a t = 'a Stream.t
      val to_stream : 'a t -> 'a Stream.t
      val of_stream : 'a Stream.t -> 'a t
      exception Failure
      exception Error of string
      exception Expected_streams_of_equal_length
      val next : 'a t -> 'a option
      val next_exn : 'a t -> 'a
      val peek : 'a t -> 'a option
      val npeek : 'a t -> int -> 'a list
      val junk : 'a t -> unit
      val count : 'a t -> int
      val is_empty : 'a t -> bool
      val from : (int -> 'a option) -> 'a t
      val of_channel : in_channel -> char t
      val strings_of_channel : ?buffer_size:int -> in_channel -> string t
      val range : ?until:int -> int -> int t
      val empty : unit -> 'a t
      val init : int -> f:(int -> 'a) -> 'a t
      val singleton : 'a -> 'a t
      val unfold : 'a -> f:('a -> ('b * 'a) option) -> 'b t
      val unfoldi : 'a -> f:(int -> 'a -> ('b * 'a) option) -> 'b t
      val of_lazy : 'a t lazy_t -> 'a t
      val iter : 'a t -> f:('a -> unit) -> unit
      val iter2 : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
      val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
      val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
      val fold2 : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
      val fold2_exn :
        'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
      val scanl : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
      val scan : 'a t -> f:('a -> 'a -> 'a) -> 'a t
      val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
      val iter2i_exn :
        'a t -> 'b t -> f:(int -> int -> 'a -> 'b -> unit) -> unit
      val iter2i : 'a t -> 'b t -> f:(int -> int -> 'a -> 'b -> unit) -> unit
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
      val fold2i_exn :
        'a t ->
        'b t -> init:'c -> f:(int -> int -> 'c -> 'a -> 'b -> 'c) -> 'c
      val fold2i :
        'a t ->
        'b t -> init:'c -> f:(int -> int -> 'c -> 'a -> 'b -> 'c) -> 'c
      val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a
      val sum : int t -> int
      val fsum : float t -> float
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_exn : 'a t -> f:('a -> bool) -> 'a
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val take : 'a t -> n:int -> 'a t
      val take_while : 'a t -> f:('a -> bool) -> 'a t
      val drop : 'a t -> n:int -> unit
      val drop_while : 'a t -> f:('a -> bool) -> unit
      val skip : 'a t -> n:int -> 'a t
      val skip_while : 'a t -> f:('a -> bool) -> 'a t
      val take_whilei : 'a t -> f:(int -> 'a -> bool) -> 'a t
      val drop_whilei : 'a t -> f:(int -> 'a -> bool) -> unit
      val skip_whilei : 'a t -> f:(int -> 'a -> bool) -> 'a t
      val span : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val group : 'a t -> f:('a -> 'b) -> 'a t t
      val group_by : 'a t -> eq:('a -> 'a -> bool) -> 'a t t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
      val filter : 'a t -> f:('a -> bool) -> 'a t
      val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val append : 'a t -> 'a t -> 'a t
      val concat : 'a t t -> 'a t
      val combine : 'a t * 'b t -> ('a * 'b) t
      val uncombine : ('a * 'b) t -> 'a t * 'b t
      val merge : 'a t -> 'a t -> cmp:('a -> 'a -> int) -> 'a t
      val partition : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val uniq : 'a t -> 'a t
      val of_list : 'a list -> 'a t
      val to_list : 'a t -> 'a list
      val of_array : 'a array -> 'a t
      val to_array : 'a t -> 'a array
      val of_hashtbl : ('a, 'b) Core.Std.Hashtbl.t -> ('a * 'b) t
      val to_hashtbl : ('a * 'b) t -> ('a, 'b) Core.Std.Hashtbl.t
      val of_map : ('a, 'b, 'c) Core.Std.Map.t -> ('a * 'b) t
      val to_map : ('a * 'b) t -> ('a, 'b) Core.Std.Map.Poly.t
      val of_set : ('a, 'b) Core.Std.Set.t -> 'a t
      val to_set : 'a t -> 'a Core.Std.Set.Poly.t
      val of_string : string -> char t
      val result_to_exn :
        ('output, 'error) Core.Std.Result.t t ->
        error_to_exn:('error -> exn) -> 'output t
      module Infix :
        sig
          val ( -- ) : int -> int -> int t
          val ( --^ ) : int -> int -> int t
          val ( --. ) : float * float -> float -> float t
          val ( --- ) : int -> int -> int t
          val ( /@ ) : 'a t -> ('a -> 'b) -> 'b t
          val ( // ) : 'a t -> ('a -> bool) -> 'a t
          val ( //@ ) : 'a t -> ('a -> 'b option) -> 'b t
        end
    end
  exception Bug of string
  exception Finally of exn * exn
  val unimplemented : string -> 'a Core_kernel.Or_error.t
  type read_only = Core_kernel.Common.read_only
  type immutable = Core_kernel.Common.immutable
  type read_write = Core_kernel.Common.read_write
  type never_returns = Core_kernel.Never_returns.never_returns
  val never_returns : never_returns -> 'a
  val protect : f:(unit -> 'a) -> finally:(unit -> unit) -> 'a
  val protectx : f:('b -> 'a) -> 'b -> finally:('b -> unit) -> 'a
  val fst3 : 'a * 'b * 'c -> 'a
  val snd3 : 'b * 'a * 'c -> 'a
  val trd3 : 'b * 'c * 'a -> 'a
  val uw : 'a option -> 'a
  val is_none : 'a option -> bool
  val is_some : 'a option -> bool
  val ( |! ) : 'a -> ('a -> 'b) -> 'b
  val ( |> ) : 'a -> ('a -> 'b) -> 'b
  val ident : 'a -> 'a
  val const : 'a -> 'b -> 'a
  val ( ==> ) : bool -> bool -> bool
  val failwiths : string -> 'a -> ('a -> Sexplib.Sexp.t) -> 'b
  val failwithp :
    Lexing.position -> string -> 'a -> ('a -> Sexplib.Sexp.t) -> 'b
  val does_raise : (unit -> 'a) -> bool
  val ok_exn : 'a Core_kernel.Or_error.t -> 'a
  val error :
    string -> 'a -> ('a -> Sexplib.Sexp.t) -> 'b Core_kernel.Or_error.t
  type 'a return =
    'a Core_kernel.Common.return = private {
    return : 'b. 'a -> 'b;
  }
  val with_return : ('a return -> 'a) -> 'a
  val phys_equal : 'a -> 'a -> bool
  val ( == ) :
    [ `Consider_using_phys_equal ] ->
    [ `Consider_using_phys_equal ] -> [ `Consider_using_phys_equal ]
  val ( != ) :
    [ `Consider_using_phys_equal ] ->
    [ `Consider_using_phys_equal ] -> [ `Consider_using_phys_equal ]
  val force : 'a Lazy.t -> 'a
  val stage : 'a -> 'a Core_kernel.Staged.t
  val unstage : 'a Core_kernel.Staged.t -> 'a
  exception C_malloc_exn of int * int
  val seek_out :
    [ `Deprecated_use_out_channel ] ->
    [ `Deprecated_use_out_channel ] -> [ `Deprecated_use_out_channel ]
  val pos_out :
    [ `Deprecated_use_out_channel ] -> [ `Deprecated_use_out_channel ]
  val out_channel_length :
    [ `Deprecated_use_out_channel ] -> [ `Deprecated_use_out_channel ]
  val seek_in :
    [ `Deprecated_use_in_channel ] ->
    [ `Deprecated_use_in_channel ] -> [ `Deprecated_use_in_channel ]
  val pos_in :
    [ `Deprecated_use_in_channel ] -> [ `Deprecated_use_in_channel ]
  val in_channel_length :
    [ `Deprecated_use_in_channel ] -> [ `Deprecated_use_in_channel ]
  val modf : [ `Deprecated_use_float_modf ] -> [ `Deprecated_use_float_modf ]
  val truncate :
    [ `Deprecated_use_float_iround_towards_zero ] ->
    [ `Deprecated_use_float_iround_towards_zero ]
  val close_in :
    [ `Deprecated_use_in_channel ] -> [ `Deprecated_use_in_channel ]
  val close_out :
    [ `Deprecated_use_out_channel ] -> [ `Deprecated_use_out_channel ]
  val ( & ) :
    [ `Deprecated_use_two_ampersands ] ->
    [ `Deprecated_use_two_ampersands ] -> [ `Deprecated_use_two_ampersands ]
  val max_int : [ `Deprecated_use_int_module ]
  val min_int : [ `Deprecated_use_int_module ]
  val ceil :
    [ `Deprecated_use__Float__round_up ] ->
    [ `Deprecated_use__Float__round_up ]
  val floor :
    [ `Deprecated_use__Float__round_down ] ->
    [ `Deprecated_use__Float__round_down ]
  val abs_float :
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val mod_float :
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val frexp :
    [ `Deprecated_use_float_module ] ->
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val ldexp :
    [ `Deprecated_use_float_module ] ->
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val float_of_int :
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val max_float : [ `Deprecated_use_float_module ]
  val min_float : [ `Deprecated_use_float_module ]
  val epsilon_float : [ `Deprecated_use_float_module ]
  val classify_float :
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val string_of_float :
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val float_of_string :
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  val infinity : [ `Deprecated_use_float_module ]
  val neg_infinity : [ `Deprecated_use_float_module ]
  val nan : [ `Deprecated_use_float_module ]
  val int_of_float :
    [ `Deprecated_use_float_module ] -> [ `Deprecated_use_float_module ]
  type fpclass = [ `Deprecated_use_float_module ]
  val compare_read_only : read_only -> read_only -> int
  val bin_read_only : read_only Bin_prot.Type_class.t
  val bin_read_read_only : read_only Bin_prot.Read_ml.reader
  val bin_read_read_only_ : read_only Bin_prot.Unsafe_read_c.reader
  val bin_read_read_only__ : (int -> read_only) Bin_prot.Unsafe_read_c.reader
  val bin_reader_read_only : read_only Bin_prot.Type_class.reader
  val bin_size_read_only : read_only Bin_prot.Size.sizer
  val bin_write_read_only : read_only Bin_prot.Write_ml.writer
  val bin_write_read_only_ : read_only Bin_prot.Unsafe_write_c.writer
  val bin_writer_read_only : read_only Bin_prot.Type_class.writer
  val read_only_of_sexp : Sexplib.Sexp.t -> read_only
  val sexp_of_read_only : read_only -> Sexplib.Sexp.t
  val compare_immutable : immutable -> immutable -> int
  val bin_immutable : immutable Bin_prot.Type_class.t
  val bin_read_immutable : immutable Bin_prot.Read_ml.reader
  val bin_read_immutable_ : immutable Bin_prot.Unsafe_read_c.reader
  val bin_read_immutable__ : (int -> immutable) Bin_prot.Unsafe_read_c.reader
  val bin_reader_immutable : immutable Bin_prot.Type_class.reader
  val bin_size_immutable : immutable Bin_prot.Size.sizer
  val bin_write_immutable : immutable Bin_prot.Write_ml.writer
  val bin_write_immutable_ : immutable Bin_prot.Unsafe_write_c.writer
  val bin_writer_immutable : immutable Bin_prot.Type_class.writer
  val immutable_of_sexp : Sexplib.Sexp.t -> immutable
  val sexp_of_immutable : immutable -> Sexplib.Sexp.t
  val compare_read_write : read_write -> read_write -> int
  val bin_read_write : read_write Bin_prot.Type_class.t
  val bin_read_read_write : read_write Bin_prot.Read_ml.reader
  val bin_read_read_write_ : read_write Bin_prot.Unsafe_read_c.reader
  val bin_read_read_write__ :
    (int -> read_write) Bin_prot.Unsafe_read_c.reader
  val bin_reader_read_write : read_write Bin_prot.Type_class.reader
  val bin_size_read_write : read_write Bin_prot.Size.sizer
  val bin_write_read_write : read_write Bin_prot.Write_ml.writer
  val bin_write_read_write_ : read_write Bin_prot.Unsafe_write_c.writer
  val bin_writer_read_write : read_write Bin_prot.Type_class.writer
  val read_write_of_sexp : Sexplib.Sexp.t -> read_write
  val sexp_of_read_write : read_write -> Sexplib.Sexp.t
  val sexp_of_never_returns : never_returns -> Sexplib.Sexp.t
  val ( ^/ ) : string -> string -> string
  val ( |? ) : 'a option -> 'a -> 'a
  module List :
    sig
      type 'a t = 'a list
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      val bind : 'a t -> ('a -> 'b t) -> 'b t
      val return : 'a -> 'a t
      val join : 'a t t -> 'a t
      val ignore : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      val of_list : 'a t -> 'a t
      val nth : 'a t -> int -> 'a option
      val nth_exn : 'a t -> int -> 'a
      val rev : 'a t -> 'a t
      val rev_append : 'a t -> 'a t -> 'a t
      val unordered_append : 'a t -> 'a t -> 'a t
      val rev_map : 'a t -> f:('a -> 'b) -> 'b t
      val fold_left : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
      val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
      val rev_map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
      val fold2_exn :
        'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
      val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
      val exists2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
      val filter : 'a t -> f:('a -> bool) -> 'a t
      val rev_filter : 'a t -> f:('a -> bool) -> 'a t
      val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t
      val partition_map :
        'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
      val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val split_n : 'a t -> int -> 'a t * 'a t
      val sort : cmp:('a -> 'a -> int) -> 'a t -> 'a t
      val stable_sort : cmp:('a -> 'a -> int) -> 'a t -> 'a t
      val merge : 'a t -> 'a t -> cmp:('a -> 'a -> int) -> 'a t
      val hd : 'a t -> 'a option
      val tl : 'a t -> 'a t option
      val hd_exn : 'a t -> 'a
      val tl_exn : 'a t -> 'a t
      val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option
      val find_exn : 'a t -> f:('a -> bool) -> 'a
      val append : 'a t -> 'a t -> 'a t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val concat_map : 'a t -> f:('a -> 'b t) -> 'b t
      val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t
      val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
      val rev_map3_exn :
        'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t
      val map3_exn : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t
      val rev_map_append : 'a t -> 'b t -> f:('a -> 'b) -> 'b t
      val fold_right : 'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
      val unzip : ('a * 'b) t -> 'a t * 'b t
      val zip : 'a t -> 'b t -> ('a * 'b) t option
      val zip_exn : 'a t -> 'b t -> ('a * 'b) t
      val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
      val rev_mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
      val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
      val foldi : 'a t -> f:(int -> 'b -> 'a -> 'b) -> init:'b -> 'b
      val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
      val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
      val group : 'a t -> break:('a -> 'a -> bool) -> 'a t t
      val groupi : 'a t -> break:(int -> 'a -> 'a -> bool) -> 'a t t
      val last : 'a t -> 'a option
      val last_exn : 'a t -> 'a
      val remove_consecutive_duplicates :
        'a t -> equal:('a -> 'a -> bool) -> 'a t
      val dedup : ?compare:('a -> 'a -> int) -> 'a t -> 'a t
      val contains_dup : ?compare:('a -> 'a -> int) -> 'a t -> bool
      val find_a_dup : ?compare:('a -> 'a -> int) -> 'a t -> 'a option
      exception Duplicate_found of (unit -> Sexplib.Sexp.t) * string
      val exn_if_dup :
        ?compare:('a -> 'a -> int) ->
        ?context:string -> 'a t -> to_sexp:('a -> Sexplib.Sexp.t) -> unit
      val count : 'a t -> f:('a -> bool) -> int
      val range :
        ?stride:int ->
        ?start:[ `exclusive | `inclusive ] ->
        ?stop:[ `exclusive | `inclusive ] -> int -> int -> int t
      val init : int -> f:(int -> 'a) -> 'a t
      val rev_filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val rev_filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
      val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
      val filter_opt : 'a option t -> 'a t
      module Assoc :
        sig
          type ('a, 'b) t = ('a * 'b) list
          val add :
            ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> 'b -> ('a, 'b) t
          val find :
            ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> 'b option
          val find_exn : ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> 'b
          val mem : ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> bool
          val remove :
            ('a, 'b) t -> ?equal:('a -> 'a -> bool) -> 'a -> ('a, 'b) t
          val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
          val inverse : ('a, 'b) t -> ('b, 'a) t
          val compare :
            ('a -> 'a -> int) ->
            ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'a) ->
            (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
        end
      val sub : 'a t -> pos:int -> len:int -> 'a t
      val slice : 'a t -> int -> int -> 'a t
      val take : 'a t -> int -> 'a t
      val drop : 'a t -> int -> 'a t
      val take_while : 'a t -> f:('a -> bool) -> 'a t
      val drop_while : 'a t -> f:('a -> bool) -> 'a t
      val split_while : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val concat : 'a t t -> 'a t
      val concat_no_order : 'a t t -> 'a t
      val cons : 'a -> 'a t -> 'a t
      val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
      val to_string : f:('a -> string) -> 'a t -> string
      val permute :
        ?random_state:Core_kernel.Core_random.State.t -> 'a t -> 'a t
      val is_sorted : 'a t -> compare:('a -> 'a -> int) -> bool
      val compare : 'a t -> 'a t -> cmp:('a -> 'a -> int) -> int
      val equal : 'a t -> 'a t -> equal:('a -> 'a -> bool) -> bool
      module Infix : sig val ( @ ) : 'a t -> 'a t -> 'a t end
      val transpose : 'a t t -> 'a t t option
      val transpose_exn : 'a t t -> 'a t t
      val intersperse : 'a list -> sep:'a -> 'a list
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
      val stable_dedup : 'a list -> 'a list
      val stable_dedup_staged :
        compare:('a -> 'a -> int) ->
        ('a list -> 'a list) Core_kernel.Staged.t
    end
  module Arg :
    sig
      type spec =
        Arg.spec =
          Unit of (unit -> unit)
        | Bool of (bool -> unit)
        | Set of bool ref
        | Clear of bool ref
        | String of (string -> unit)
        | Set_string of string ref
        | Int of (int -> unit)
        | Set_int of int ref
        | Float of (float -> unit)
        | Set_float of float ref
        | Tuple of spec list
        | Symbol of string list * (string -> unit)
        | Rest of (string -> unit)
      type key = string
      type doc = string
      type usage_msg = string
      type anon_fun = string -> unit
      val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit
      val parse_argv :
        ?current:int ref ->
        string array ->
        (key * spec * doc) list -> anon_fun -> usage_msg -> unit
      exception Help of string
      exception Bad of string
      val usage : (key * spec * doc) list -> usage_msg -> unit
      val usage_string : (key * spec * doc) list -> usage_msg -> string
      val align : (key * spec * doc) list -> (key * spec * doc) list
      val current : int ref
      type t = key * spec * doc
      val sort_and_align : (key * spec * doc) list -> (key * spec * doc) list
    end
  module Array :
    sig
      type 'a t = 'a array
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val count : 'a t -> f:('a -> bool) -> int
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val max_length : int
      external get : 'a t -> int -> 'a = "%array_safe_get"
      external set : 'a t -> int -> 'a -> unit = "%array_safe_set"
      external unsafe_get : 'a t -> int -> 'a = "%array_unsafe_get"
      external unsafe_set : 'a t -> int -> 'a -> unit = "%array_unsafe_set"
      val create : len:int -> 'a -> 'a t
      val init : int -> f:(int -> 'a) -> 'a t
      val make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t
      val append : 'a t -> 'a t -> 'a t
      val concat : 'a t list -> 'a t
      val copy : 'a t -> 'a t
      val fill : 'a t -> pos:int -> len:int -> 'a -> unit
      val blit : ('a t, 'a t) Core_kernel.Blit_intf.blit
      val blito : ('a t, 'a t) Core_kernel.Blit_intf.blito
      val unsafe_blit : ('a t, 'a t) Core_kernel.Blit_intf.blit
      val sub : ('a t, 'a t) Core_kernel.Blit_intf.sub
      val subo : ('a t, 'a t) Core_kernel.Blit_intf.subo
      module Int :
        sig
          type t = int t
          val blit : (t, t) Core_kernel.Blit_intf.blit
          val blito : (t, t) Core_kernel.Blit_intf.blito
          val sub : (t, t) Core_kernel.Blit_intf.sub
          val subo : (t, t) Core_kernel.Blit_intf.subo
          external unsafe_blit :
            src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
            = "core_array_unsafe_int_blit" "noalloc"
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          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
      module Float :
        sig
          type t = float t
          val blit : (t, t) Core_kernel.Blit_intf.blit
          val blito : (t, t) Core_kernel.Blit_intf.blito
          val sub : (t, t) Core_kernel.Blit_intf.sub
          val subo : (t, t) Core_kernel.Blit_intf.subo
          external unsafe_blit :
            src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
            = "core_array_unsafe_float_blit" "noalloc"
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          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
      val of_list : 'a list -> 'a t
      val map : f:('a -> 'b) -> 'a t -> 'b t
      val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
      val mapi : f:(int -> 'a -> 'b) -> 'a t -> 'b t
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
      val fold_right : 'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
      val sort :
        ?pos:int -> ?len:int -> 'a t -> cmp:('a -> 'a -> int) -> unit
      val stable_sort : 'a t -> cmp:('a -> 'a -> int) -> unit
      val is_sorted : 'a t -> cmp:('a -> 'a -> int) -> bool
      val concat_map : 'a t -> f:('a -> 'b array) -> 'b array
      val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t
      val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
      val normalize : 'a t -> int -> int
      val slice : 'a t -> int -> int -> 'a t
      val nget : 'a t -> int -> 'a
      val nset : 'a t -> int -> 'a -> unit
      val filter_opt : 'a option t -> 'a t
      val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
      val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
      val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
      val fold2_exn :
        'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
      val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
      val filter : f:('a -> bool) -> 'a t -> 'a t
      val filteri : f:(int -> 'a -> bool) -> 'a t -> 'a t
      val swap : 'a t -> int -> int -> unit
      val rev_inplace : 'a t -> unit
      val of_list_rev : 'a list -> 'a t
      val of_list_map : 'a list -> f:('a -> 'b) -> 'b t
      val of_list_rev_map : 'a list -> f:('a -> 'b) -> 'b t
      val replace : 'a t -> int -> f:('a -> 'a) -> unit
      val replace_all : 'a t -> f:('a -> 'a) -> unit
      val find_exn : 'a t -> f:('a -> bool) -> 'a
      val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option
      val findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a
      val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
      val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
      val permute :
        ?random_state:Core_kernel.Core_random.State.t -> 'a t -> unit
      val combine : 'a t -> 'b t -> ('a * 'b) t
      val split : ('a * 'b) t -> 'a t * 'b t
      val sorted_copy : 'a t -> cmp:('a -> 'a -> int) -> 'a t
      val last : 'a t -> 'a
      val empty : unit -> 'a t
      val equal : 'a t -> 'a t -> equal:('a -> 'a -> bool) -> bool
      module Infix : sig val ( <|> ) : 'a t -> int * int -> 'a t end
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
      val range : 'a t -> int Biocaml_internal_pervasives.Stream.t
    end
  val ( <|> ) : 'a Array.t -> int * int -> 'a Array.t
  module Backtrace :
    sig
      type t = Core.Backtrace.t
      val get : (unit -> t) Core_kernel.Std.Or_error.t
      val get_opt : unit -> t option
      val to_string : t -> string
      module Exn :
        sig
          val am_recording : unit -> bool
          val set_recording : bool -> unit
          val most_recent : unit -> string
        end
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Bag :
    sig
      module Elt :
        sig
          type 'a t = 'a Core_kernel.Bag.Elt.t
          val equal : 'a t -> 'a t -> bool
          val sexp_of_t :
            ('a -> Core_kernel.Std_internal.Sexp.t) ->
            'a t -> Core_kernel.Std_internal.Sexp.t
          val value : 'a t -> 'a
        end
      type 'a t = 'a Core_kernel.Bag.t
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val count : 'a t -> f:('a -> bool) -> int
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val invariant : 'a t -> unit
      val create : unit -> 'a t
      val add : 'a t -> 'a -> 'a Elt.t
      val remove : 'a t -> 'a Elt.t -> unit
      val choose : 'a t -> 'a Elt.t option
      val remove_one : 'a t -> 'a option
      val clear : 'a t -> unit
      val fold_elt : 'a t -> init:'b -> f:('b -> 'a Elt.t -> 'b) -> 'b
      val iter_elt : 'a t -> f:('a Elt.t -> unit) -> unit
      val find_elt : 'a t -> f:('a -> bool) -> 'a Elt.t option
      val until_empty : 'a t -> ('a -> unit) -> unit
      val transfer : src:'a t -> dst:'a t -> unit
      val of_list : 'a list -> 'a t
      val unchecked_iter : 'a t -> f:('a -> unit) -> unit
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
    end
  module Big_int :
    sig
      type big_int = Big_int.big_int
      val zero_big_int : big_int
      val unit_big_int : big_int
      val minus_big_int : big_int -> big_int
      val abs_big_int : big_int -> big_int
      val add_big_int : big_int -> big_int -> big_int
      val succ_big_int : big_int -> big_int
      val add_int_big_int : int -> big_int -> big_int
      val sub_big_int : big_int -> big_int -> big_int
      val pred_big_int : big_int -> big_int
      val mult_big_int : big_int -> big_int -> big_int
      val mult_int_big_int : int -> big_int -> big_int
      val square_big_int : big_int -> big_int
      val sqrt_big_int : big_int -> big_int
      val quomod_big_int : big_int -> big_int -> big_int * big_int
      val div_big_int : big_int -> big_int -> big_int
      val mod_big_int : big_int -> big_int -> big_int
      val gcd_big_int : big_int -> big_int -> big_int
      val power_int_positive_int : int -> int -> big_int
      val power_big_int_positive_int : big_int -> int -> big_int
      val power_int_positive_big_int : int -> big_int -> big_int
      val power_big_int_positive_big_int : big_int -> big_int -> big_int
      val sign_big_int : big_int -> int
      val compare_big_int : big_int -> big_int -> int
      val eq_big_int : big_int -> big_int -> bool
      val le_big_int : big_int -> big_int -> bool
      val ge_big_int : big_int -> big_int -> bool
      val lt_big_int : big_int -> big_int -> bool
      val gt_big_int : big_int -> big_int -> bool
      val max_big_int : big_int -> big_int -> big_int
      val min_big_int : big_int -> big_int -> big_int
      val num_digits_big_int : big_int -> int
      val string_of_big_int : big_int -> string
      val big_int_of_string : string -> big_int
      val big_int_of_int : int -> big_int
      val is_int_big_int : big_int -> bool
      val int_of_big_int : big_int -> int
      val big_int_of_int32 : int32 -> big_int
      val big_int_of_nativeint : nativeint -> big_int
      val big_int_of_int64 : int64 -> big_int
      val int32_of_big_int : big_int -> int32
      val nativeint_of_big_int : big_int -> nativeint
      val int64_of_big_int : big_int -> int64
      val float_of_big_int : big_int -> float
      val and_big_int : big_int -> big_int -> big_int
      val or_big_int : big_int -> big_int -> big_int
      val xor_big_int : big_int -> big_int -> big_int
      val shift_left_big_int : big_int -> int -> big_int
      val shift_right_big_int : big_int -> int -> big_int
      val shift_right_towards_zero_big_int : big_int -> int -> big_int
      val extract_big_int : big_int -> int -> int -> big_int
      val nat_of_big_int : big_int -> Nat.nat
      val big_int_of_nat : Nat.nat -> big_int
      val base_power_big_int : int -> int -> big_int -> big_int
      val sys_big_int_of_string : string -> int -> int -> big_int
      val round_futur_last_digit : string -> int -> int -> bool
      val approx_big_int : int -> big_int -> string
      val sexp_of_big_int : Big_int.big_int -> Sexplib.Sexp.t
      val big_int_of_sexp : Sexplib.Sexp.t -> Big_int.big_int
    end
  module Bigbuffer :
    sig
      type t = Core_kernel.Std.Bigbuffer.t
      val create : int -> t
      val contents : t -> string
      val big_contents : t -> Core_kernel.Bigstring.t
      val volatile_contents : t -> Core_kernel.Bigstring.t
      val blit : (t, string) Core_kernel.Blit_intf.blit
      val blito : (t, string) Core_kernel.Blit_intf.blito
      val unsafe_blit : (t, string) Core_kernel.Blit_intf.blit
      val sub : (t, string) Core_kernel.Blit_intf.sub
      val subo : (t, string) Core_kernel.Blit_intf.subo
      val nth : t -> int -> char
      val length : t -> int
      val clear : t -> unit
      val reset : t -> unit
      val add_char : t -> char -> unit
      val add_string : t -> string -> unit
      val add_substring : t -> string -> int -> int -> unit
      val add_substitute : t -> (string -> string) -> string -> unit
      val add_buffer : t -> t -> unit
      module Format :
        sig
          val formatter_of_buffer : t -> Format.formatter
          val bprintf : t -> ('a, Format.formatter, unit) format -> 'a
        end
      module Printf :
        sig val bprintf : t -> ('a, unit, string, unit) format4 -> 'a end
      val __internal : t -> Core_kernel.Bigbuffer_internal.t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val add_channel : t -> in_channel -> int -> unit
      val output_buffer : out_channel -> t -> unit
    end
  module Bigstring :
    sig
      type t = Core_kernel.Std.Bigstring.t
      val create : ?max_mem_waiting_gc:Core_kernel.Byte_units.t -> int -> t
      val init : int -> f:(int -> char) -> t
      val of_string : ?pos:int -> ?len:int -> string -> t
      val to_string : ?pos:int -> ?len:int -> t -> string
      val check_args : loc:string -> pos:int -> len:int -> t -> unit
      val get_opt_len : t -> pos:int -> int option -> int
      val length : t -> int
      val sub_shared : ?pos:int -> ?len:int -> t -> t
      val get : t -> int -> char
      val set : t -> int -> char -> unit
      external is_mmapped : t -> bool = "bigstring_is_mmapped_stub" "noalloc"
      val blit : (t, t) Core_kernel.Blit_intf.blit
      val blito : (t, t) Core_kernel.Blit_intf.blito
      val unsafe_blit : (t, t) Core_kernel.Blit_intf.blit
      val sub : (t, t) Core_kernel.Blit_intf.sub
      val subo : (t, t) Core_kernel.Blit_intf.subo
      module To_string :
        sig
          val blit : (t, string) Core_kernel.Blit_intf.blit
          val blito : (t, string) Core_kernel.Blit_intf.blito
          val unsafe_blit : (t, string) Core_kernel.Blit_intf.blit
          val sub : (t, string) Core_kernel.Blit_intf.sub
          val subo : (t, string) Core_kernel.Blit_intf.subo
        end
      module From_string :
        sig
          val blit : (string, t) Core_kernel.Blit_intf.blit
          val blito : (string, t) Core_kernel.Blit_intf.blito
          val unsafe_blit : (string, t) Core_kernel.Blit_intf.blit
          val sub : (string, t) Core_kernel.Blit_intf.sub
          val subo : (string, t) Core_kernel.Blit_intf.subo
        end
      val map_file : shared:bool -> Unix.file_descr -> int -> t
      val find : ?pos:int -> ?len:int -> char -> t -> int option
      external unsafe_destroy : t -> unit = "bigstring_destroy_stub"
      val unsafe_get_int8 : t -> pos:int -> int
      val unsafe_set_int8 : t -> pos:int -> int -> unit
      val unsafe_get_uint8 : t -> pos:int -> int
      val unsafe_set_uint8 : t -> pos:int -> int -> unit
      val unsafe_get_int16_le : t -> pos:int -> int
      val unsafe_get_int16_be : t -> pos:int -> int
      val unsafe_set_int16_le : t -> pos:int -> int -> unit
      val unsafe_set_int16_be : t -> pos:int -> int -> unit
      val unsafe_get_uint16_le : t -> pos:int -> int
      val unsafe_get_uint16_be : t -> pos:int -> int
      val unsafe_set_uint16_le : t -> pos:int -> int -> unit
      val unsafe_set_uint16_be : t -> pos:int -> int -> unit
      val unsafe_get_int32_le : t -> pos:int -> int
      val unsafe_get_int32_be : t -> pos:int -> int
      val unsafe_set_int32_le : t -> pos:int -> int -> unit
      val unsafe_set_int32_be : t -> pos:int -> int -> unit
      val unsafe_get_uint32_le : t -> pos:int -> int
      val unsafe_get_uint32_be : t -> pos:int -> int
      val unsafe_set_uint32_le : t -> pos:int -> int -> unit
      val unsafe_set_uint32_be : t -> pos:int -> int -> unit
      val unsafe_get_int64_le_exn : t -> pos:int -> int
      val unsafe_get_int64_be_exn : t -> pos:int -> int
      val unsafe_set_int64_le : t -> pos:int -> int -> unit
      val unsafe_set_int64_be : t -> pos:int -> int -> unit
      val unsafe_get_int32_t_le : t -> pos:int -> Int32.t
      val unsafe_get_int32_t_be : t -> pos:int -> Int32.t
      val unsafe_set_int32_t_le : t -> pos:int -> Int32.t -> unit
      val unsafe_set_int32_t_be : t -> pos:int -> Int32.t -> unit
      val unsafe_get_int64_t_le : t -> pos:int -> Int64.t
      val unsafe_get_int64_t_be : t -> pos:int -> Int64.t
      val unsafe_set_int64_t_le : t -> pos:int -> Int64.t -> unit
      val unsafe_set_int64_t_be : t -> pos:int -> Int64.t -> unit
      val get_padded_fixed_string :
        padding:char -> t -> pos:int -> len:int -> unit -> string
      val set_padded_fixed_string :
        padding:char -> t -> pos:int -> len:int -> string -> unit
      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
      exception IOError of int * exn
      val read :
        ?min_len:int -> Unix.file_descr -> ?pos:int -> ?len:int -> t -> int
      val really_read : Unix.file_descr -> ?pos:int -> ?len:int -> t -> unit
      val really_recv : Unix.file_descr -> ?pos:int -> ?len:int -> t -> unit
      val recvfrom_assume_fd_is_nonblocking :
        Unix.file_descr -> ?pos:int -> ?len:int -> t -> int * Unix.sockaddr
      val read_assume_fd_is_nonblocking :
        Unix.file_descr -> ?pos:int -> ?len:int -> t -> int
      val pread_assume_fd_is_nonblocking :
        Unix.file_descr -> offset:int -> ?pos:int -> ?len:int -> t -> int
      val input :
        ?min_len:int -> in_channel -> ?pos:int -> ?len:int -> t -> int
      val really_input : in_channel -> ?pos:int -> ?len:int -> t -> unit
      val really_write : Unix.file_descr -> ?pos:int -> ?len:int -> t -> unit
      val really_send_no_sigpipe :
        (Unix.file_descr -> ?pos:int -> ?len:int -> t -> unit)
        Core_kernel.Std.Or_error.t
      val send_nonblocking_no_sigpipe :
        (Unix.file_descr -> ?pos:int -> ?len:int -> t -> int option)
        Core_kernel.Std.Or_error.t
      val sendto_nonblocking_no_sigpipe :
        (Unix.file_descr ->
         ?pos:int -> ?len:int -> t -> Unix.sockaddr -> int option)
        Core_kernel.Std.Or_error.t
      val write : Unix.file_descr -> ?pos:int -> ?len:int -> t -> int
      val pwrite_assume_fd_is_nonblocking :
        Unix.file_descr -> offset:int -> ?pos:int -> ?len:int -> t -> int
      val write_assume_fd_is_nonblocking :
        Unix.file_descr -> ?pos:int -> ?len:int -> t -> int
      val writev :
        Unix.file_descr ->
        ?count:int -> t Core.Core_unix.IOVec.t array -> int
      val writev_assume_fd_is_nonblocking :
        Unix.file_descr ->
        ?count:int -> t Core.Core_unix.IOVec.t array -> int
      val recvmmsg_assume_fd_is_nonblocking :
        (Unix.file_descr ->
         ?count:int ->
         ?srcs:Unix.sockaddr array ->
         t Core.Core_unix.IOVec.t array -> lens:int array -> int)
        Core_kernel.Std.Or_error.t
      val sendmsg_nonblocking_no_sigpipe :
        (Unix.file_descr ->
         ?count:int -> t Core.Core_unix.IOVec.t array -> int option)
        Core_kernel.Std.Or_error.t
      val output :
        ?min_len:int -> out_channel -> ?pos:int -> ?len:int -> t -> int
      val really_output : out_channel -> ?pos:int -> ?len:int -> t -> unit
      external unsafe_read_assume_fd_is_nonblocking :
        Unix.file_descr -> pos:int -> len:int -> t -> int
        = "bigstring_read_assume_fd_is_nonblocking_stub"
      external unsafe_write :
        Unix.file_descr -> pos:int -> len:int -> t -> int
        = "bigstring_write_stub"
      external unsafe_write_assume_fd_is_nonblocking :
        Unix.file_descr -> pos:int -> len:int -> t -> int
        = "bigstring_write_assume_fd_is_nonblocking_stub"
      external unsafe_read :
        min_len:int -> Unix.file_descr -> pos:int -> len:int -> t -> int
        = "bigstring_read_stub"
      external unsafe_really_recv :
        Unix.file_descr -> pos:int -> len:int -> t -> unit
        = "bigstring_really_recv_stub"
      external unsafe_really_write :
        Unix.file_descr -> pos:int -> len:int -> t -> unit
        = "bigstring_really_write_stub"
      val unsafe_really_send_no_sigpipe :
        (Unix.file_descr -> pos:int -> len:int -> t -> unit)
        Core_kernel.Std.Or_error.t
      val unsafe_send_nonblocking_no_sigpipe :
        (Unix.file_descr -> pos:int -> len:int -> t -> int option)
        Core_kernel.Std.Or_error.t
      external unsafe_writev :
        Unix.file_descr -> t Core.Core_unix.IOVec.t array -> int -> int
        = "bigstring_writev_stub"
      val unsafe_sendmsg_nonblocking_no_sigpipe :
        (Unix.file_descr ->
         t Core.Core_unix.IOVec.t array -> int -> int option)
        Core_kernel.Std.Or_error.t
      external unsafe_input :
        min_len:int -> in_channel -> pos:int -> len:int -> t -> int
        = "bigstring_input_stub"
      external unsafe_output :
        min_len:int -> out_channel -> pos:int -> len:int -> t -> int
        = "bigstring_output_stub"
    end
  module Bigsubstring :
    sig
      type base = Core_kernel.Bigstring.t
      type t = Core_kernel.Bigsubstring.t
      val base : t -> base
      val pos : t -> int
      val length : t -> int
      val create : ?pos:int -> ?len:int -> base -> t
      val blit_to_string : t -> dst:string -> dst_pos:int -> unit
      val blit_to_bigstring :
        t -> dst:Core_kernel.Bigstring.t -> dst_pos:int -> unit
      val blit_from_string :
        t -> src:string -> src_pos:int -> len:int -> unit
      val blit_from_bigstring :
        t -> src:Core_kernel.Bigstring.t -> src_pos:int -> len:int -> unit
      val concat : t list -> t
      val concat_string : t list -> string
      val concat_bigstring : t list -> Core_kernel.Bigstring.t
      val of_bigstring : Core_kernel.Bigstring.t -> t
      val of_string : string -> t
      val to_bigstring : t -> Core_kernel.Bigstring.t
      val to_string : t -> string
      val drop_prefix : t -> int -> t
      val drop_suffix : t -> int -> t
      val prefix : t -> int -> t
      val suffix : t -> int -> t
    end
  module Bin_prot :
    sig
      module Common :
        sig
          type pos = int
          type pos_ref = pos ref
          type buf =
              (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout)
              Bigarray.Array1.t
          val create_buf : int -> buf
          val check_pos : buf -> pos -> unit
          val check_next : buf -> pos -> unit
          val safe_get_pos : buf -> pos_ref -> pos
          val blit_string_buf :
            ?src_pos:int -> string -> ?dst_pos:int -> buf -> len:int -> unit
          val blit_buf_string :
            ?src_pos:int -> buf -> ?dst_pos:int -> string -> len:int -> unit
          val blit_buf :
            ?src_pos:int -> src:buf -> ?dst_pos:int -> dst:buf -> int -> unit
          exception Buffer_short
          exception No_variant_match
          module ReadError :
            sig
              type t =
                Bin_prot.Common.ReadError.t =
                  Neg_int8
                | Int_code
                | Int_overflow
                | Nat0_code
                | Nat0_overflow
                | Int32_code
                | Int64_code
                | Nativeint_code
                | Unit_code
                | Bool_code
                | Option_code
                | String_too_long
                | Variant_tag
                | Array_too_long
                | Hashtbl_too_long
                | Sum_tag of string
                | Variant of string
                | Poly_rec_bound of string
                | Variant_wrong_type of string
                | Silly_type of string
                | Empty_type of string
              val to_string : t -> string
            end
          exception Read_error of ReadError.t * pos
          exception Read_exc of exn * pos
          exception Poly_rec_write of string
          exception Empty_type of string
          val raise_read_error : ReadError.t -> pos -> 'a
          val raise_read_exc : exn -> pos -> 'a
          val raise_concurrent_modification : string -> 'a
          val array_bound_error : unit -> 'a
          type vec32 =
              (float, Bigarray.float32_elt, Bigarray.fortran_layout)
              Bigarray.Array1.t
          type vec64 =
              (float, Bigarray.float64_elt, Bigarray.fortran_layout)
              Bigarray.Array1.t
          type vec = vec64
          type mat32 =
              (float, Bigarray.float32_elt, Bigarray.fortran_layout)
              Bigarray.Array2.t
          type mat64 =
              (float, Bigarray.float64_elt, Bigarray.fortran_layout)
              Bigarray.Array2.t
          type mat = mat64
          val copy_htbl_list :
            ('a, 'b) Hashtbl.t -> ('a * 'b) list -> ('a, 'b) Hashtbl.t
          external variant_of_int : int -> [>  ] = "%identity"
          external unsafe_blit_buf :
            src_pos:int ->
            src:buf -> dst_pos:int -> dst:buf -> len:int -> unit
            = "bin_prot_blit_buf_stub"
          external unsafe_blit_string_buf :
            src_pos:int -> string -> dst_pos:int -> buf -> len:int -> unit
            = "bin_prot_blit_string_buf_stub" "noalloc"
          external unsafe_blit_buf_string :
            src_pos:int -> buf -> dst_pos:int -> string -> len:int -> unit
            = "bin_prot_blit_buf_string_stub" "noalloc"
        end
      module Nat0 :
        sig
          type t = Bin_prot.Nat0.t
          val of_int : int -> t
          external unsafe_of_int : int -> t = "%identity"
        end
      module Unsafe_common :
        sig
          type sptr = Bin_prot.Unsafe_common.sptr
          type eptr = Bin_prot.Unsafe_common.eptr
          type sptr_ptr = Bin_prot.Unsafe_common.sptr_ptr
          external get_sptr : Common.buf -> pos:Common.pos -> sptr
            = "get_buf_ptr_stub" "noalloc"
          external get_eptr : Common.buf -> pos:Common.pos -> eptr
            = "get_buf_ptr_stub" "noalloc"
          external shift_sptr : sptr -> int -> sptr = "shift_sptr_stub"
            "noalloc"
          external get_eptr_from_sptr_ptr :
            sptr_ptr -> pos:Common.pos -> eptr = "get_eptr_from_sptr_ptr"
            "noalloc"
          external get_buf_pos : start:sptr -> cur:sptr -> Common.pos
            = "get_buf_pos_stub" "noalloc"
          external get_safe_buf_pos :
            Common.buf -> start:sptr -> cur:sptr -> Common.pos
            = "get_safe_buf_pos_stub" "noalloc"
          external alloc_sptr_ptr : Common.buf -> pos:Common.pos -> sptr_ptr
            = "alloc_sptr_ptr_stub" "noalloc"
          external dealloc_sptr_ptr : Common.buf -> sptr_ptr -> Common.pos
            = "dealloc_sptr_ptr_stub" "noalloc"
          external get_sptr_ptr : sptr_ptr -> Common.buf -> Common.pos
            = "get_sptr_ptr_stub" "noalloc"
          external set_sptr_ptr :
            sptr_ptr -> Common.buf -> pos:Common.pos -> unit
            = "set_sptr_ptr_stub" "noalloc"
          external get_sptr_ptr_sptr : sptr_ptr -> sptr
            = "get_sptr_ptr_sptr_stub" "noalloc"
          external set_sptr_ptr_sptr : sptr_ptr -> sptr -> unit
            = "set_sptr_ptr_sptr_stub" "noalloc"
          external get_ptr_string : sptr -> eptr -> string
            = "get_ptr_string_stub"
          val get_read_init :
            Common.buf -> pos_ref:Common.pos ref -> sptr_ptr * eptr
        end
      module Unsafe_read_c :
        sig
          exception Error of Common.ReadError.t
          val raise_variant_wrong_type : string -> 'a
          type 'a reader = Unsafe_common.sptr_ptr -> Unsafe_common.eptr -> 'a
          type ('a, 'b) reader1 = 'a reader -> 'b reader
          type ('a, 'b, 'c) reader2 = 'a reader -> ('b, 'c) reader1
          type ('a, 'b, 'c, 'd) reader3 = 'a reader -> ('b, 'c, 'd) reader2
          val bin_read_unit : unit reader
          val bin_read_bool : bool reader
          val bin_read_string : string reader
          val bin_read_char : char reader
          val bin_read_int : int reader
          val bin_read_float : float reader
          val bin_read_int32 : int32 reader
          val bin_read_int64 : int64 reader
          val bin_read_nativeint : nativeint reader
          val bin_read_nat0 : Nat0.t reader
          val bin_read_ref : ('a, 'a ref) reader1
          val bin_read_lazy : ('a, 'a lazy_t) reader1
          val bin_read_option : ('a, 'a option) reader1
          val bin_read_pair : ('a, 'b, 'a * 'b) reader2
          val bin_read_triple : ('a, 'b, 'c, 'a * 'b * 'c) reader3
          val bin_read_list : ('a, 'a list) reader1
          val bin_read_array : ('a, 'a array) reader1
          val bin_read_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) reader2
          val bin_read_float32_vec : Common.vec32 reader
          val bin_read_float64_vec : Common.vec64 reader
          val bin_read_vec : Common.vec reader
          val bin_read_float32_mat : Common.mat32 reader
          val bin_read_float64_mat : Common.mat64 reader
          val bin_read_mat : Common.mat reader
          val bin_read_bigstring : Common.buf reader
          val bin_read_float_array : float array reader
          val bin_read_variant_int : int reader
          val bin_read_variant_tag : [>  ] reader
          val bin_read_raw_string :
            (string -> pos:int -> len:int -> unit) reader
          val bin_read_int_8bit : int reader
          val bin_read_int_16bit : int reader
          val bin_read_int_32bit : int reader
          val bin_read_int_64bit : int reader
          val bin_read_int64_bits : int64 reader
          val bin_read_network16_int : int reader
          val bin_read_network32_int : int reader
          val bin_read_network32_int32 : int32 reader
          val bin_read_network64_int : int reader
          val bin_read_network64_int64 : int64 reader
        end
      module Read_ml :
        sig
          type 'a reader = Common.buf -> pos_ref:Common.pos_ref -> 'a
          type ('a, 'b) reader1 = 'a reader -> 'b reader
          type ('a, 'b, 'c) reader2 = 'a reader -> ('b, 'c) reader1
          type ('a, 'b, 'c, 'd) reader3 = 'a reader -> ('b, 'c, 'd) reader2
          val bin_read_unit : unit reader
          val bin_read_bool : bool reader
          val bin_read_string : string reader
          val bin_read_char : char reader
          val bin_read_int : int reader
          val bin_read_nat0 : Nat0.t reader
          val bin_read_float : float reader
          val bin_read_int32 : int32 reader
          val bin_read_int64 : int64 reader
          val bin_read_nativeint : nativeint reader
          val bin_read_ref : ('a, 'a ref) reader1
          val bin_read_lazy : ('a, 'a lazy_t) reader1
          val bin_read_option : ('a, 'a option) reader1
          val bin_read_pair : ('a, 'b, 'a * 'b) reader2
          val bin_read_triple : ('a, 'b, 'c, 'a * 'b * 'c) reader3
          val bin_read_list : ('a, 'a list) reader1
          val bin_read_array : ('a, 'a array) reader1
          val bin_read_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) reader2
          val bin_read_float32_vec : Common.vec32 reader
          val bin_read_float64_vec : Common.vec64 reader
          val bin_read_vec : Common.vec reader
          val bin_read_float32_mat : Common.mat32 reader
          val bin_read_float64_mat : Common.mat64 reader
          val bin_read_mat : Common.mat reader
          val bin_read_bigstring : Common.buf reader
          val bin_read_float_array : float array reader
          val bin_read_variant_int : int reader
          val bin_read_variant_tag : [>  ] reader
          val bin_read_int_8bit : int reader
          val bin_read_int_16bit : int reader
          val bin_read_int_32bit : int reader
          val bin_read_int_64bit : int reader
          val bin_read_int64_bits : int64 reader
          val bin_read_network16_int : int reader
          val bin_read_network32_int : int reader
          val bin_read_network32_int32 : int32 reader
          val bin_read_network64_int : int reader
          val bin_read_network64_int64 : int64 reader
        end
      module Unsafe_write_c :
        sig
          type 'a writer =
              Unsafe_common.sptr ->
              Unsafe_common.eptr -> 'a -> Unsafe_common.sptr
          type ('a, 'b) writer1 = 'a writer -> 'b writer
          type ('a, 'b, 'c) writer2 = 'a writer -> ('b, 'c) writer1
          type ('a, 'b, 'c, 'd) writer3 = 'a writer -> ('b, 'c, 'd) writer2
          val bin_write_unit : unit writer
          val bin_write_bool : bool writer
          val bin_write_string : string writer
          val bin_write_char : char writer
          val bin_write_int : int writer
          val bin_write_float : float writer
          val bin_write_int32 : int32 writer
          val bin_write_int64 : int64 writer
          val bin_write_nativeint : nativeint writer
          val bin_write_nat0 : Nat0.t writer
          val bin_write_ref : ('a, 'a ref) writer1
          val bin_write_lazy : ('a, 'a lazy_t) writer1
          val bin_write_option : ('a, 'a option) writer1
          val bin_write_pair : ('a, 'b, 'a * 'b) writer2
          val bin_write_triple : ('a, 'b, 'c, 'a * 'b * 'c) writer3
          val bin_write_list : ('a, 'a list) writer1
          val bin_write_array : ('a, 'a array) writer1
          val bin_write_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) writer2
          val bin_write_float32_vec : Common.vec32 writer
          val bin_write_float64_vec : Common.vec64 writer
          val bin_write_vec : Common.vec writer
          val bin_write_float32_mat : Common.mat32 writer
          val bin_write_float64_mat : Common.mat64 writer
          val bin_write_mat : Common.mat writer
          val bin_write_bigstring : Common.buf writer
          val bin_write_float_array : float array writer
          val bin_write_variant_tag : [>  ] writer
          val bin_write_raw_string :
            Unsafe_common.sptr ->
            Unsafe_common.eptr ->
            string -> pos:int -> len:int -> Unsafe_common.sptr
          val bin_write_int_8bit : int writer
          val bin_write_int_16bit : int writer
          val bin_write_int_32bit : int writer
          val bin_write_int_64bit : int writer
          val bin_write_int64_bits : int64 writer
          val bin_write_network16_int : int writer
          val bin_write_network32_int : int writer
          val bin_write_network32_int32 : int32 writer
          val bin_write_network64_int : int writer
          val bin_write_network64_int64 : int64 writer
          val bin_write_array_no_length : ('a, 'a array) writer1
        end
      module Write_ml :
        sig
          type 'a writer = Common.buf -> pos:Common.pos -> 'a -> Common.pos
          type ('a, 'b) writer1 = 'a writer -> 'b writer
          type ('a, 'b, 'c) writer2 = 'a writer -> ('b, 'c) writer1
          type ('a, 'b, 'c, 'd) writer3 = 'a writer -> ('b, 'c, 'd) writer2
          val bin_write_unit : unit writer
          val bin_write_bool : bool writer
          val bin_write_string : string writer
          val bin_write_char : char writer
          val bin_write_int : int writer
          val bin_write_nat0 : Nat0.t writer
          val bin_write_float : float writer
          val bin_write_int32 : int32 writer
          val bin_write_int64 : int64 writer
          val bin_write_nativeint : nativeint writer
          val bin_write_ref : ('a, 'a ref) writer1
          val bin_write_lazy : ('a, 'a lazy_t) writer1
          val bin_write_option : ('a, 'a option) writer1
          val bin_write_pair : ('a, 'b, 'a * 'b) writer2
          val bin_write_triple : ('a, 'b, 'c, 'a * 'b * 'c) writer3
          val bin_write_list : ('a, 'a list) writer1
          val bin_write_array : ('a, 'a array) writer1
          val bin_write_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) writer2
          val bin_write_float32_vec : Common.vec32 writer
          val bin_write_float64_vec : Common.vec64 writer
          val bin_write_vec : Common.vec writer
          val bin_write_float32_mat : Common.mat32 writer
          val bin_write_float64_mat : Common.mat64 writer
          val bin_write_mat : Common.mat writer
          val bin_write_bigstring : Common.buf writer
          val bin_write_float_array : float array writer
          val bin_write_variant_tag : [>  ] writer
          val bin_write_int_8bit : int writer
          val bin_write_int_16bit : int writer
          val bin_write_int_32bit : int writer
          val bin_write_int_64bit : int writer
          val bin_write_int64_bits : int64 writer
          val bin_write_network16_int : int writer
          val bin_write_network32_int : int writer
          val bin_write_network32_int32 : int32 writer
          val bin_write_network64_int : int writer
          val bin_write_network64_int64 : int64 writer
          val bin_write_array_no_length : ('a, 'a array) writer1
        end
      module Map_to_safe :
        sig
          type 'a reader = 'a Read_ml.reader
          type ('a, 'b) reader1 =
              'a Unsafe_read_c.reader -> 'b Read_ml.reader
          type ('a, 'b, 'c) reader2 =
              'a Unsafe_read_c.reader -> ('b, 'c) reader1
          type ('a, 'b, 'c, 'd) reader3 =
              'a Unsafe_read_c.reader -> ('b, 'c, 'd) reader2
          type 'a writer = 'a Write_ml.writer
          type ('a, 'b) writer1 =
              'a Unsafe_write_c.writer -> 'b Write_ml.writer
          type ('a, 'b, 'c) writer2 =
              'a Unsafe_write_c.writer -> ('b, 'c) writer1
          type ('a, 'b, 'c, 'd) writer3 =
              'a Unsafe_write_c.writer -> ('b, 'c, 'd) writer2
        end
      module Size :
        sig
          type 'a sizer = 'a -> int
          type ('a, 'b) sizer1 = 'a sizer -> 'b sizer
          type ('a, 'b, 'c) sizer2 = 'a sizer -> ('b, 'c) sizer1
          type ('a, 'b, 'c, 'd) sizer3 = 'a sizer -> ('b, 'c, 'd) sizer2
          val bin_size_unit : unit sizer
          val bin_size_bool : bool sizer
          val bin_size_string : string sizer
          val bin_size_char : char sizer
          val bin_size_int : int sizer
          val bin_size_float : float sizer
          val bin_size_int32 : int32 sizer
          val bin_size_int64 : int64 sizer
          val bin_size_nativeint : nativeint sizer
          val bin_size_nat0 : Nat0.t sizer
          val bin_size_ref : ('a, 'a ref) sizer1
          val bin_size_lazy_t : ('a, 'a lazy_t) sizer1
          val bin_size_lazy : ('a, 'a lazy_t) sizer1
          val bin_size_option : ('a, 'a option) sizer1
          val bin_size_pair : ('a, 'b, 'a * 'b) sizer2
          val bin_size_triple : ('a, 'b, 'c, 'a * 'b * 'c) sizer3
          val bin_size_list : ('a, 'a list) sizer1
          val bin_size_array : ('a, 'a array) sizer1
          val bin_size_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) sizer2
          val bin_size_float32_vec : Common.vec32 sizer
          val bin_size_float64_vec : Common.vec64 sizer
          val bin_size_vec : Common.vec sizer
          val bin_size_float32_mat : Common.mat32 sizer
          val bin_size_float64_mat : Common.mat64 sizer
          val bin_size_mat : Common.mat sizer
          val bin_size_bigstring : Common.buf sizer
          val bin_size_float_array : float array sizer
          val bin_size_variant_tag : [>  ] sizer
          val bin_size_int_8bit : int sizer
          val bin_size_int_16bit : int sizer
          val bin_size_int_32bit : int sizer
          val bin_size_int_64bit : int sizer
          val bin_size_int64_bits : int64 sizer
          val bin_size_network16_int : int sizer
          val bin_size_network32_int : int sizer
          val bin_size_network32_int32 : int32 sizer
          val bin_size_network64_int : int sizer
          val bin_size_network64_int64 : int64 sizer
          val bin_size_array_no_length : ('a, 'a array) sizer1
        end
      module Type_class :
        sig
          type 'a writer =
            'a Bin_prot.Type_class.writer = {
            size : 'a Size.sizer;
            write : 'a Write_ml.writer;
            unsafe_write : 'a Unsafe_write_c.writer;
          }
          type 'a reader =
            'a Bin_prot.Type_class.reader = {
            read : 'a Read_ml.reader;
            unsafe_read : 'a Unsafe_read_c.reader;
            unsafe_vtag_read : (int -> 'a) Unsafe_read_c.reader;
          }
          type 'a t =
            'a Bin_prot.Type_class.t = {
            writer : 'a writer;
            reader : 'a reader;
          }
          type 'a writer0 = 'a writer
          type 'a reader0 = 'a reader
          type 'a t0 = 'a t
          module S1 :
            sig
              type ('a, 'b) writer = 'a writer0 -> 'b writer0
              type ('a, 'b) reader = 'a reader0 -> 'b reader0
              type ('a, 'b) t = 'a t0 -> 'b t0
            end
          module S2 :
            sig
              type ('a, 'b, 'c) writer = 'a writer0 -> ('b, 'c) S1.writer
              type ('a, 'b, 'c) reader = 'a reader0 -> ('b, 'c) S1.reader
              type ('a, 'b, 'c) t = 'a t0 -> ('b, 'c) S1.t
            end
          module S3 :
            sig
              type ('a, 'b, 'c, 'd) writer =
                  'a writer0 -> ('b, 'c, 'd) S2.writer
              type ('a, 'b, 'c, 'd) reader =
                  'a reader0 -> ('b, 'c, 'd) S2.reader
              type ('a, 'b, 'c, 'd) t = 'a t0 -> ('b, 'c, 'd) S2.t
            end
          val bin_writer_unit : unit writer
          val bin_reader_unit : unit reader
          val bin_unit : unit t
          val bin_writer_bool : bool writer
          val bin_reader_bool : bool reader
          val bin_bool : bool t
          val bin_writer_string : string writer
          val bin_reader_string : string reader
          val bin_string : string t
          val bin_writer_char : char writer
          val bin_reader_char : char reader
          val bin_char : char t
          val bin_writer_int : int writer
          val bin_reader_int : int reader
          val bin_int : int t
          val bin_writer_float : float writer
          val bin_reader_float : float reader
          val bin_float : float t
          val bin_writer_int32 : int32 writer
          val bin_reader_int32 : int32 reader
          val bin_int32 : int32 t
          val bin_writer_int64 : int64 writer
          val bin_reader_int64 : int64 reader
          val bin_int64 : int64 t
          val bin_writer_nativeint : nativeint writer
          val bin_reader_nativeint : nativeint reader
          val bin_nativeint : nativeint t
          val bin_writer_nat0 : Nat0.t writer
          val bin_reader_nat0 : Nat0.t reader
          val bin_nat0 : Nat0.t t
          val bin_writer_ref : ('a, 'a ref) S1.writer
          val bin_reader_ref : ('a, 'a ref) S1.reader
          val bin_ref : ('a, 'a ref) S1.t
          val bin_writer_lazy : ('a, 'a lazy_t) S1.writer
          val bin_reader_lazy : ('a, 'a lazy_t) S1.reader
          val bin_lazy : ('a, 'a lazy_t) S1.t
          val bin_writer_option : ('a, 'a option) S1.writer
          val bin_reader_option : ('a, 'a option) S1.reader
          val bin_option : ('a, 'a option) S1.t
          val bin_writer_pair : ('a, 'b, 'a * 'b) S2.writer
          val bin_reader_pair : ('a, 'b, 'a * 'b) S2.reader
          val bin_pair : ('a, 'b, 'a * 'b) S2.t
          val bin_writer_triple : ('a, 'b, 'c, 'a * 'b * 'c) S3.writer
          val bin_reader_triple : ('a, 'b, 'c, 'a * 'b * 'c) S3.reader
          val bin_triple : ('a, 'b, 'c, 'a * 'b * 'c) S3.t
          val bin_writer_list : ('a, 'a list) S1.writer
          val bin_reader_list : ('a, 'a list) S1.reader
          val bin_list : ('a, 'a list) S1.t
          val bin_writer_array : ('a, 'a array) S1.writer
          val bin_reader_array : ('a, 'a array) S1.reader
          val bin_array : ('a, 'a array) S1.t
          val bin_writer_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) S2.writer
          val bin_reader_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) S2.reader
          val bin_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) S2.t
          val bin_writer_float32_vec : Common.vec32 writer
          val bin_reader_float32_vec : Common.vec32 reader
          val bin_float32_vec : Common.vec32 t
          val bin_writer_float64_vec : Common.vec64 writer
          val bin_reader_float64_vec : Common.vec64 reader
          val bin_float64_vec : Common.vec64 t
          val bin_writer_vec : Common.vec writer
          val bin_reader_vec : Common.vec reader
          val bin_vec : Common.vec t
          val bin_writer_float32_mat : Common.mat32 writer
          val bin_reader_float32_mat : Common.mat32 reader
          val bin_float32_mat : Common.mat32 t
          val bin_writer_float64_mat : Common.mat64 writer
          val bin_reader_float64_mat : Common.mat64 reader
          val bin_float64_mat : Common.mat64 t
          val bin_writer_mat : Common.mat writer
          val bin_reader_mat : Common.mat reader
          val bin_mat : Common.mat t
          val bin_writer_bigstring : Common.buf writer
          val bin_reader_bigstring : Common.buf reader
          val bin_bigstring : Common.buf t
          val bin_writer_float_array : float array writer
          val bin_reader_float_array : float array reader
          val bin_float_array : float array t
          val bin_writer_variant_tag : [>  ] writer
          val bin_reader_variant_tag : [>  ] reader
          val bin_variant_tag : [>  ] t
          val bin_writer_int_8bit : int writer
          val bin_reader_int_8bit : int reader
          val bin_int_8bit : int t
          val bin_writer_int_16bit : int writer
          val bin_reader_int_16bit : int reader
          val bin_int_16bit : int t
          val bin_writer_int_32bit : int writer
          val bin_reader_int_32bit : int reader
          val bin_int_32bit : int t
          val bin_writer_int_64bit : int writer
          val bin_reader_int_64bit : int reader
          val bin_int_64bit : int t
          val bin_writer_int64_bits : int64 writer
          val bin_reader_int64_bits : int64 reader
          val bin_int64_bits : int64 t
          val bin_writer_network16_int : int writer
          val bin_reader_network16_int : int reader
          val bin_network16_int : int t
          val bin_writer_network32_int : int writer
          val bin_reader_network32_int : int reader
          val bin_network32_int : int t
          val bin_writer_network32_int32 : int32 writer
          val bin_reader_network32_int32 : int32 reader
          val bin_network32_int32 : int32 t
          val bin_writer_network64_int : int writer
          val bin_reader_network64_int : int reader
          val bin_network64_int : int t
          val bin_writer_network64_int64 : int64 writer
          val bin_reader_network64_int64 : int64 reader
          val bin_network64_int64 : int64 t
          val bin_writer_array_no_length : ('a, 'a array) S1.writer
          val cnv_writer : ('a -> 'b) -> 'b writer -> 'a writer
          val cnv_reader : ('b -> 'a) -> 'b reader -> 'a reader
          val cnv : ('a -> 'b) -> ('b -> 'a) -> 'b t -> 'a t
        end
      module Binable :
        sig
          module type S =
            sig
              type t
              val bin_size_t : t Size.sizer
              val bin_write_t : t Map_to_safe.writer
              val bin_write_t_ : t Unsafe_write_c.writer
              val bin_read_t : t Read_ml.reader
              val bin_read_t_ : t Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Unsafe_read_c.reader
              val bin_writer_t : t Type_class.writer
              val bin_reader_t : t Type_class.reader
              val bin_t : t Type_class.t
            end
          module type S1 =
            sig
              type 'a t
              val bin_size_t : ('a, 'a t) Size.sizer1
              val bin_write_t : ('a, 'a t) Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Unsafe_read_c.reader1
              val bin_read_t__ : ('a, int -> 'a t) Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Type_class.S1.reader
              val bin_t : ('a, 'a t) Type_class.S1.t
            end
          module type S2 =
            sig
              type ('a, 'b) t
              val bin_size_t : ('a, 'b, ('a, 'b) t) Size.sizer2
              val bin_write_t : ('a, 'b, ('a, 'b) t) Map_to_safe.writer2
              val bin_write_t_ : ('a, 'b, ('a, 'b) t) Unsafe_write_c.writer2
              val bin_read_t : ('a, 'b, ('a, 'b) t) Map_to_safe.reader2
              val bin_read_t_ : ('a, 'b, ('a, 'b) t) Unsafe_read_c.reader2
              val bin_read_t__ :
                ('a, 'b, int -> ('a, 'b) t) Unsafe_read_c.reader2
              val bin_writer_t : ('a, 'b, ('a, 'b) t) Type_class.S2.writer
              val bin_reader_t : ('a, 'b, ('a, 'b) t) Type_class.S2.reader
              val bin_t : ('a, 'b, ('a, 'b) t) Type_class.S2.t
            end
        end
      module Write_c :
        sig
          val unsafe_get_init :
            Common.buf ->
            pos:Common.pos ->
            Unsafe_common.sptr * Unsafe_common.sptr * Unsafe_common.eptr
          val make : 'a Unsafe_write_c.writer -> 'a Write_ml.writer
          val make1 :
            ('a, 'b) Unsafe_write_c.writer1 -> ('a, 'b) Write_ml.writer1
          val make2 :
            ('a, 'b, 'c) Unsafe_write_c.writer2 ->
            ('a, 'b, 'c) Write_ml.writer2
          val make3 :
            ('a, 'b, 'c, 'd) Unsafe_write_c.writer3 ->
            ('a, 'b, 'c, 'd) Write_ml.writer3
          val unmake :
            'a Write_ml.writer ->
            Common.buf ->
            start:Unsafe_common.sptr -> 'a Unsafe_write_c.writer
          val bin_write_unit : unit Write_ml.writer
          val bin_write_bool : bool Write_ml.writer
          val bin_write_string : string Write_ml.writer
          val bin_write_char : char Write_ml.writer
          val bin_write_int : int Write_ml.writer
          val bin_write_nat0 : Nat0.t Write_ml.writer
          val bin_write_float : float Write_ml.writer
          val bin_write_int32 : int32 Write_ml.writer
          val bin_write_int64 : int64 Write_ml.writer
          val bin_write_nativeint : nativeint Write_ml.writer
          val bin_write_ref : ('a, 'a ref) Write_ml.writer1
          val bin_write_lazy : ('a, 'a lazy_t) Write_ml.writer1
          val bin_write_option : ('a, 'a option) Write_ml.writer1
          val bin_write_pair : ('a, 'b, 'a * 'b) Write_ml.writer2
          val bin_write_triple : ('a, 'b, 'c, 'a * 'b * 'c) Write_ml.writer3
          val bin_write_list : ('a, 'a list) Write_ml.writer1
          val bin_write_array : ('a, 'a array) Write_ml.writer1
          val bin_write_hashtbl :
            ('a, 'b, ('a, 'b) Hashtbl.t) Write_ml.writer2
          val bin_write_float32_vec : Common.vec32 Write_ml.writer
          val bin_write_float64_vec : Common.vec64 Write_ml.writer
          val bin_write_vec : Common.vec Write_ml.writer
          val bin_write_float32_mat : Common.mat32 Write_ml.writer
          val bin_write_float64_mat : Common.mat64 Write_ml.writer
          val bin_write_mat : Common.mat Write_ml.writer
          val bin_write_bigstring : Common.buf Write_ml.writer
          val bin_write_float_array : float array Write_ml.writer
          val bin_write_variant_tag : [>  ] Write_ml.writer
          val bin_write_array_no_length : ('a, 'a array) Write_ml.writer1
          val bin_write_int_64bit : int Write_ml.writer
          val bin_write_int64_bits : int64 Write_ml.writer
          val bin_write_network16_int : int Write_ml.writer
          val bin_write_network32_int : int Write_ml.writer
          val bin_write_network32_int32 : int32 Write_ml.writer
          val bin_write_network64_int : int Write_ml.writer
          val bin_write_network64_int64 : int64 Write_ml.writer
        end
      module Read_c :
        sig
          val make : 'a Unsafe_read_c.reader -> 'a Read_ml.reader
          val make1 :
            ('a, 'b) Unsafe_read_c.reader1 -> ('a, 'b) Read_ml.reader1
          val make2 :
            ('a, 'b, 'c) Unsafe_read_c.reader2 ->
            ('a, 'b, 'c) Read_ml.reader2
          val make3 :
            ('a, 'b, 'c, 'd) Unsafe_read_c.reader3 ->
            ('a, 'b, 'c, 'd) Read_ml.reader3
          val unmake :
            'b Read_ml.reader -> Common.buf -> 'b Unsafe_read_c.reader
          val handle_error :
            Common.buf -> Unsafe_common.sptr_ptr -> Common.ReadError.t -> 'a
          val handle_exc : Common.buf -> Unsafe_common.sptr_ptr -> exn -> 'a
          val at_end :
            Common.buf ->
            Unsafe_common.sptr_ptr -> Common.pos_ref -> 'a -> 'a
          val bin_read_unit : unit Read_ml.reader
          val bin_read_bool : bool Read_ml.reader
          val bin_read_string : string Read_ml.reader
          val bin_read_char : char Read_ml.reader
          val bin_read_int : int Read_ml.reader
          val bin_read_nat0 : Nat0.t Read_ml.reader
          val bin_read_float : float Read_ml.reader
          val bin_read_int32 : int32 Read_ml.reader
          val bin_read_int64 : int64 Read_ml.reader
          val bin_read_nativeint : nativeint Read_ml.reader
          val bin_read_ref : ('a, 'a ref) Read_ml.reader1
          val bin_read_lazy : ('a, 'a lazy_t) Read_ml.reader1
          val bin_read_option : ('a, 'a option) Read_ml.reader1
          val bin_read_pair : ('a, 'b, 'a * 'b) Read_ml.reader2
          val bin_read_triple : ('a, 'b, 'c, 'a * 'b * 'c) Read_ml.reader3
          val bin_read_list : ('a, 'a list) Read_ml.reader1
          val bin_read_array : ('a, 'a array) Read_ml.reader1
          val bin_read_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Read_ml.reader2
          val bin_read_float32_vec : Common.vec32 Read_ml.reader
          val bin_read_float64_vec : Common.vec64 Read_ml.reader
          val bin_read_vec : Common.vec Read_ml.reader
          val bin_read_float32_mat : Common.mat32 Read_ml.reader
          val bin_read_float64_mat : Common.mat64 Read_ml.reader
          val bin_read_mat : Common.mat Read_ml.reader
          val bin_read_bigstring : Common.buf Read_ml.reader
          val bin_read_float_array : float array Read_ml.reader
          val bin_read_variant_int : int Read_ml.reader
          val bin_read_variant_tag : [>  ] Read_ml.reader
          val bin_read_int_64bit : int Read_ml.reader
          val bin_read_int64_bits : int64 Read_ml.reader
          val bin_read_network16_int : int Read_ml.reader
          val bin_read_network32_int : int Read_ml.reader
          val bin_read_network32_int32 : int32 Read_ml.reader
          val bin_read_network64_int : int Read_ml.reader
          val bin_read_network64_int64 : int64 Read_ml.reader
        end
      module Std :
        sig
          type 'a sizer = 'a -> int
          type ('a, 'b) sizer1 = 'a sizer -> 'b sizer
          type ('a, 'b, 'c) sizer2 = 'a sizer -> ('b, 'c) sizer1
          type ('a, 'b, 'c, 'd) sizer3 = 'a sizer -> ('b, 'c, 'd) sizer2
          val bin_size_unit : unit sizer
          val bin_size_bool : bool sizer
          val bin_size_string : string sizer
          val bin_size_char : char sizer
          val bin_size_int : int sizer
          val bin_size_float : float sizer
          val bin_size_int32 : int32 sizer
          val bin_size_int64 : int64 sizer
          val bin_size_nativeint : nativeint sizer
          val bin_size_nat0 : Nat0.t sizer
          val bin_size_ref : ('a, 'a ref) sizer1
          val bin_size_lazy_t : ('a, 'a lazy_t) sizer1
          val bin_size_lazy : ('a, 'a lazy_t) sizer1
          val bin_size_option : ('a, 'a option) sizer1
          val bin_size_pair : ('a, 'b, 'a * 'b) sizer2
          val bin_size_triple : ('a, 'b, 'c, 'a * 'b * 'c) sizer3
          val bin_size_list : ('a, 'a list) sizer1
          val bin_size_array : ('a, 'a array) sizer1
          val bin_size_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) sizer2
          val bin_size_float32_vec : Common.vec32 sizer
          val bin_size_float64_vec : Common.vec64 sizer
          val bin_size_vec : Common.vec sizer
          val bin_size_float32_mat : Common.mat32 sizer
          val bin_size_float64_mat : Common.mat64 sizer
          val bin_size_mat : Common.mat sizer
          val bin_size_bigstring : Common.buf sizer
          val bin_size_float_array : float array sizer
          val bin_size_variant_tag : [>  ] sizer
          val bin_size_int_8bit : int sizer
          val bin_size_int_16bit : int sizer
          val bin_size_int_32bit : int sizer
          val bin_size_int_64bit : int sizer
          val bin_size_int64_bits : int64 sizer
          val bin_size_network16_int : int sizer
          val bin_size_network32_int : int sizer
          val bin_size_network32_int32 : int32 sizer
          val bin_size_network64_int : int sizer
          val bin_size_network64_int64 : int64 sizer
          val bin_size_array_no_length : ('a, 'a array) sizer1
          val bin_unit : unit Type_class.t
          val bin_writer_unit : unit Type_class.writer
          val bin_write_unit_ : unit Unsafe_write_c.writer
          val bin_write_unit : unit Write_ml.writer
          val bin_reader_unit : unit Type_class.reader
          val bin_read_unit : unit Read_ml.reader
          val bin_read_unit_ : unit Unsafe_read_c.reader
          val bin_read_unit__ : 'a -> 'b -> 'c -> 'd
          val bin_bool : bool Type_class.t
          val bin_writer_bool : bool Type_class.writer
          val bin_write_bool_ : bool Unsafe_write_c.writer
          val bin_write_bool : bool Write_ml.writer
          val bin_reader_bool : bool Type_class.reader
          val bin_read_bool : bool Read_ml.reader
          val bin_read_bool_ : bool Unsafe_read_c.reader
          val bin_read_bool__ : 'a -> 'b -> 'c -> 'd
          val bin_string : string Type_class.t
          val bin_writer_string : string Type_class.writer
          val bin_write_string_ : string Unsafe_write_c.writer
          val bin_write_string : string Write_ml.writer
          val bin_reader_string : string Type_class.reader
          val bin_read_string : string Read_ml.reader
          val bin_read_string_ : string Unsafe_read_c.reader
          val bin_read_string__ : 'a -> 'b -> 'c -> 'd
          val bin_char : char Type_class.t
          val bin_writer_char : char Type_class.writer
          val bin_write_char_ : char Unsafe_write_c.writer
          val bin_write_char : char Write_ml.writer
          val bin_reader_char : char Type_class.reader
          val bin_read_char : char Read_ml.reader
          val bin_read_char_ : char Unsafe_read_c.reader
          val bin_read_char__ : 'a -> 'b -> 'c -> 'd
          val bin_int : int Type_class.t
          val bin_writer_int : int Type_class.writer
          val bin_write_int_ : int Unsafe_write_c.writer
          val bin_write_int : int Write_ml.writer
          val bin_reader_int : int Type_class.reader
          val bin_read_int : int Read_ml.reader
          val bin_read_int_ : int Unsafe_read_c.reader
          val bin_read_int__ : 'a -> 'b -> 'c -> 'd
          val bin_float : float Type_class.t
          val bin_writer_float : float Type_class.writer
          val bin_write_float_ : float Unsafe_write_c.writer
          val bin_write_float : float Write_ml.writer
          val bin_reader_float : float Type_class.reader
          val bin_read_float : float Read_ml.reader
          val bin_read_float_ : float Unsafe_read_c.reader
          val bin_read_float__ : 'a -> 'b -> 'c -> 'd
          val bin_int32 : int32 Type_class.t
          val bin_writer_int32 : int32 Type_class.writer
          val bin_write_int32_ : int32 Unsafe_write_c.writer
          val bin_write_int32 : int32 Write_ml.writer
          val bin_reader_int32 : int32 Type_class.reader
          val bin_read_int32 : int32 Read_ml.reader
          val bin_read_int32_ : int32 Unsafe_read_c.reader
          val bin_read_int32__ : 'a -> 'b -> 'c -> 'd
          val bin_int64 : int64 Type_class.t
          val bin_writer_int64 : int64 Type_class.writer
          val bin_write_int64_ : int64 Unsafe_write_c.writer
          val bin_write_int64 : int64 Write_ml.writer
          val bin_reader_int64 : int64 Type_class.reader
          val bin_read_int64 : int64 Read_ml.reader
          val bin_read_int64_ : int64 Unsafe_read_c.reader
          val bin_read_int64__ : 'a -> 'b -> 'c -> 'd
          val bin_nativeint : nativeint Type_class.t
          val bin_writer_nativeint : nativeint Type_class.writer
          val bin_write_nativeint_ : nativeint Unsafe_write_c.writer
          val bin_write_nativeint : nativeint Write_ml.writer
          val bin_reader_nativeint : nativeint Type_class.reader
          val bin_read_nativeint : nativeint Read_ml.reader
          val bin_read_nativeint_ : nativeint Unsafe_read_c.reader
          val bin_read_nativeint__ : 'a -> 'b -> 'c -> 'd
          val bin_ref : ('a, 'a ref) Type_class.S1.t
          val bin_writer_ref : ('a, 'a ref) Type_class.S1.writer
          val bin_write_ref_ : ('a, 'a ref) Unsafe_write_c.writer1
          val bin_write_ref : ('a, 'a ref) Write_ml.writer1
          val bin_reader_ref : ('a, 'a ref) Type_class.S1.reader
          val bin_read_ref : ('a, 'a ref) Read_ml.reader1
          val bin_read_ref_ : ('a, 'a ref) Unsafe_read_c.reader1
          val bin_read_ref__ : 'a -> 'b -> 'c -> 'd -> 'e
          val bin_lazy_t : ('a, 'a lazy_t) Type_class.S1.t
          val bin_writer_lazy_t : ('a, 'a lazy_t) Type_class.S1.writer
          val bin_write_lazy_t_ : ('a, 'a lazy_t) Unsafe_write_c.writer1
          val bin_write_lazy_t : ('a, 'a lazy_t) Write_ml.writer1
          val bin_reader_lazy_t : ('a, 'a lazy_t) Type_class.S1.reader
          val bin_read_lazy_t : ('a, 'a lazy_t) Read_ml.reader1
          val bin_read_lazy_t_ : ('a, 'a lazy_t) Unsafe_read_c.reader1
          val bin_read_lazy_t__ : 'a -> 'b -> 'c -> 'd -> 'e
          val bin_lazy : ('a, 'a lazy_t) Type_class.S1.t
          val bin_writer_lazy : ('a, 'a lazy_t) Type_class.S1.writer
          val bin_write_lazy_ : ('a, 'a lazy_t) Unsafe_write_c.writer1
          val bin_write_lazy : ('a, 'a lazy_t) Write_ml.writer1
          val bin_reader_lazy : ('a, 'a lazy_t) Type_class.S1.reader
          val bin_read_lazy : ('a, 'a lazy_t) Read_ml.reader1
          val bin_read_lazy_ : ('a, 'a lazy_t) Unsafe_read_c.reader1
          val bin_read_lazy__ : 'a -> 'b -> 'c -> 'd -> 'e
          val bin_option : ('a, 'a option) Type_class.S1.t
          val bin_writer_option : ('a, 'a option) Type_class.S1.writer
          val bin_write_option_ : ('a, 'a option) Unsafe_write_c.writer1
          val bin_write_option : ('a, 'a option) Write_ml.writer1
          val bin_reader_option : ('a, 'a option) Type_class.S1.reader
          val bin_read_option : ('a, 'a option) Read_ml.reader1
          val bin_read_option_ : ('a, 'a option) Unsafe_read_c.reader1
          val bin_read_option__ : 'a -> 'b -> 'c -> 'd -> 'e
          val bin_list : ('a, 'a list) Type_class.S1.t
          val bin_writer_list : ('a, 'a list) Type_class.S1.writer
          val bin_write_list_ : ('a, 'a list) Unsafe_write_c.writer1
          val bin_write_list : ('a, 'a list) Write_ml.writer1
          val bin_reader_list : ('a, 'a list) Type_class.S1.reader
          val bin_read_list : ('a, 'a list) Read_ml.reader1
          val bin_read_list_ : ('a, 'a list) Unsafe_read_c.reader1
          val bin_read_list__ : 'a -> 'b -> 'c -> 'd -> 'e
          val bin_array : ('a, 'a array) Type_class.S1.t
          val bin_writer_array : ('a, 'a array) Type_class.S1.writer
          val bin_write_array_ : ('a, 'a array) Unsafe_write_c.writer1
          val bin_write_array : ('a, 'a array) Write_ml.writer1
          val bin_reader_array : ('a, 'a array) Type_class.S1.reader
          val bin_read_array : ('a, 'a array) Read_ml.reader1
          val bin_read_array_ : ('a, 'a array) Unsafe_read_c.reader1
          val bin_read_array__ : 'a -> 'b -> 'c -> 'd -> 'e
          val bin_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Type_class.S2.t
          val bin_writer_hashtbl :
            ('a, 'b, ('a, 'b) Hashtbl.t) Type_class.S2.writer
          val bin_write_hashtbl_ :
            ('a, 'b, ('a, 'b) Hashtbl.t) Unsafe_write_c.writer2
          val bin_write_hashtbl :
            ('a, 'b, ('a, 'b) Hashtbl.t) Write_ml.writer2
          val bin_reader_hashtbl :
            ('a, 'b, ('a, 'b) Hashtbl.t) Type_class.S2.reader
          val bin_read_hashtbl : ('a, 'b, ('a, 'b) Hashtbl.t) Read_ml.reader2
          val bin_read_hashtbl_ :
            ('a, 'b, ('a, 'b) Hashtbl.t) Unsafe_read_c.reader2
          val bin_read_hashtbl__ : 'a -> 'b -> 'c -> 'd -> 'e -> 'f
          val bin_bigstring : Common.buf Type_class.t
          val bin_writer_bigstring : Common.buf Type_class.writer
          val bin_write_bigstring_ : Common.buf Unsafe_write_c.writer
          val bin_write_bigstring : Common.buf Write_ml.writer
          val bin_reader_bigstring : Common.buf Type_class.reader
          val bin_read_bigstring : Common.buf Read_ml.reader
          val bin_read_bigstring_ : Common.buf Unsafe_read_c.reader
          val bin_read_bigstring__ : 'a -> 'b -> 'c -> 'd
          val bin_mat : Common.mat Type_class.t
          val bin_writer_mat : Common.mat Type_class.writer
          val bin_write_mat_ : Common.mat Unsafe_write_c.writer
          val bin_write_mat : Common.mat Write_ml.writer
          val bin_reader_mat : Common.mat Type_class.reader
          val bin_read_mat : Common.mat Read_ml.reader
          val bin_read_mat_ : Common.mat Unsafe_read_c.reader
          val bin_read_mat__ : 'a -> 'b -> 'c -> 'd
          val bin_float32_mat : Common.mat32 Type_class.t
          val bin_writer_float32_mat : Common.mat32 Type_class.writer
          val bin_write_float32_mat_ : Common.mat32 Unsafe_write_c.writer
          val bin_write_float32_mat : Common.mat32 Write_ml.writer
          val bin_reader_float32_mat : Common.mat32 Type_class.reader
          val bin_read_float32_mat : Common.mat32 Read_ml.reader
          val bin_read_float32_mat_ : Common.mat32 Unsafe_read_c.reader
          val bin_read_float32_mat__ : 'a -> 'b -> 'c -> 'd
          val bin_float64_mat : Common.mat64 Type_class.t
          val bin_writer_float64_mat : Common.mat64 Type_class.writer
          val bin_write_float64_mat_ : Common.mat64 Unsafe_write_c.writer
          val bin_write_float64_mat : Common.mat64 Write_ml.writer
          val bin_reader_float64_mat : Common.mat64 Type_class.reader
          val bin_read_float64_mat : Common.mat64 Read_ml.reader
          val bin_read_float64_mat_ : Common.mat64 Unsafe_read_c.reader
          val bin_read_float64_mat__ : 'a -> 'b -> 'c -> 'd
          val bin_vec : Common.vec Type_class.t
          val bin_writer_vec : Common.vec Type_class.writer
          val bin_write_vec_ : Common.vec Unsafe_write_c.writer
          val bin_write_vec : Common.vec Write_ml.writer
          val bin_reader_vec : Common.vec Type_class.reader
          val bin_read_vec : Common.vec Read_ml.reader
          val bin_read_vec_ : Common.vec Unsafe_read_c.reader
          val bin_read_vec__ : 'a -> 'b -> 'c -> 'd
          val bin_float32_vec : Common.vec32 Type_class.t
          val bin_writer_float32_vec : Common.vec32 Type_class.writer
          val bin_write_float32_vec_ : Common.vec32 Unsafe_write_c.writer
          val bin_write_float32_vec : Common.vec32 Write_ml.writer
          val bin_reader_float32_vec : Common.vec32 Type_class.reader
          val bin_read_float32_vec : Common.vec32 Read_ml.reader
          val bin_read_float32_vec_ : Common.vec32 Unsafe_read_c.reader
          val bin_read_float32_vec__ : 'a -> 'b -> 'c -> 'd
          val bin_float64_vec : Common.vec64 Type_class.t
          val bin_writer_float64_vec : Common.vec64 Type_class.writer
          val bin_write_float64_vec_ : Common.vec64 Unsafe_write_c.writer
          val bin_write_float64_vec : Common.vec64 Write_ml.writer
          val bin_reader_float64_vec : Common.vec64 Type_class.reader
          val bin_read_float64_vec : Common.vec64 Read_ml.reader
          val bin_read_float64_vec_ : Common.vec64 Unsafe_read_c.reader
          val bin_read_float64_vec__ : 'a -> 'b -> 'c -> 'd
        end
      module Utils :
        sig
          val bin_dump :
            ?header:bool -> 'a Type_class.writer -> 'a -> Common.buf
          val bin_read_stream :
            ?max_size:int ->
            read:(Common.buf -> pos:int -> len:int -> unit) ->
            'a Type_class.reader -> 'a
          module type Make_binable_spec =
            sig
              module Binable : Binable.S
              type t
              val to_binable : t -> Binable.t
              val of_binable : Binable.t -> t
            end
          module Make_binable :
            functor (Bin_spec : Make_binable_spec) ->
              sig
                val bin_size_t : Bin_spec.t Size.sizer
                val bin_write_t : Bin_spec.t Map_to_safe.writer
                val bin_write_t_ : Bin_spec.t Unsafe_write_c.writer
                val bin_read_t : Bin_spec.t Read_ml.reader
                val bin_read_t_ : Bin_spec.t Unsafe_read_c.reader
                val bin_read_t__ : (int -> Bin_spec.t) Unsafe_read_c.reader
                val bin_writer_t : Bin_spec.t Type_class.writer
                val bin_reader_t : Bin_spec.t Type_class.reader
                val bin_t : Bin_spec.t Type_class.t
              end
          module type Make_binable1_spec =
            sig
              module Binable : Binable.S1
              type 'a t
              val to_binable : 'a t -> 'a Binable.t
              val of_binable : 'a Binable.t -> 'a t
            end
          module Make_binable1 :
            functor (Bin_spec : Make_binable1_spec) ->
              sig
                val bin_size_t : ('a, 'a Bin_spec.t) Size.sizer1
                val bin_write_t : ('a, 'a Bin_spec.t) Map_to_safe.writer1
                val bin_write_t_ : ('a, 'a Bin_spec.t) Unsafe_write_c.writer1
                val bin_read_t : ('a, 'a Bin_spec.t) Map_to_safe.reader1
                val bin_read_t_ : ('a, 'a Bin_spec.t) Unsafe_read_c.reader1
                val bin_read_t__ :
                  ('a, int -> 'a Bin_spec.t) Unsafe_read_c.reader1
                val bin_writer_t : ('a, 'a Bin_spec.t) Type_class.S1.writer
                val bin_reader_t : ('a, 'a Bin_spec.t) Type_class.S1.reader
                val bin_t : ('a, 'a Bin_spec.t) Type_class.S1.t
              end
          module type Make_binable2_spec =
            sig
              module Binable : Binable.S2
              type ('a, 'b) t
              val to_binable : ('a, 'b) t -> ('a, 'b) Binable.t
              val of_binable : ('a, 'b) Binable.t -> ('a, 'b) t
            end
          module Make_binable2 :
            functor (Bin_spec : Make_binable2_spec) ->
              sig
                val bin_size_t : ('a, 'b, ('a, 'b) Bin_spec.t) Size.sizer2
                val bin_write_t :
                  ('a, 'b, ('a, 'b) Bin_spec.t) Map_to_safe.writer2
                val bin_write_t_ :
                  ('a, 'b, ('a, 'b) Bin_spec.t) Unsafe_write_c.writer2
                val bin_read_t :
                  ('a, 'b, ('a, 'b) Bin_spec.t) Map_to_safe.reader2
                val bin_read_t_ :
                  ('a, 'b, ('a, 'b) Bin_spec.t) Unsafe_read_c.reader2
                val bin_read_t__ :
                  ('a, 'b, int -> ('a, 'b) Bin_spec.t) Unsafe_read_c.reader2
                val bin_writer_t :
                  ('a, 'b, ('a, 'b) Bin_spec.t) Type_class.S2.writer
                val bin_reader_t :
                  ('a, 'b, ('a, 'b) Bin_spec.t) Type_class.S2.reader
                val bin_t : ('a, 'b, ('a, 'b) Bin_spec.t) Type_class.S2.t
              end
          module type Make_iterable_binable_spec =
            sig
              type t
              type el
              type acc
              val module_name : string option
              val length : t -> int
              val iter : t -> f:(el -> unit) -> unit
              val init : int -> acc
              val insert : acc -> el -> int -> acc
              val finish : acc -> t
              val bin_size_el : el Size.sizer
              val bin_write_el_ : el Unsafe_write_c.writer
              val bin_read_el_ : el Unsafe_read_c.reader
            end
          module Make_iterable_binable :
            functor (Iterable_spec : Make_iterable_binable_spec) ->
              sig
                val bin_size_t : Iterable_spec.t Size.sizer
                val bin_write_t : Iterable_spec.t Map_to_safe.writer
                val bin_write_t_ : Iterable_spec.t Unsafe_write_c.writer
                val bin_read_t : Iterable_spec.t Read_ml.reader
                val bin_read_t_ : Iterable_spec.t Unsafe_read_c.reader
                val bin_read_t__ :
                  (int -> Iterable_spec.t) Unsafe_read_c.reader
                val bin_writer_t : Iterable_spec.t Type_class.writer
                val bin_reader_t : Iterable_spec.t Type_class.reader
                val bin_t : Iterable_spec.t Type_class.t
              end
          module type Make_iterable_binable1_spec =
            sig
              type 'a t
              type 'a el
              type 'a acc
              val module_name : string option
              val length : 'a t -> int
              val iter : 'a t -> f:('a el -> unit) -> unit
              val init : int -> 'a acc
              val insert : 'a acc -> 'a el -> int -> 'a acc
              val finish : 'a acc -> 'a t
              val bin_size_el : ('a, 'a el) Size.sizer1
              val bin_write_el_ : ('a, 'a el) Unsafe_write_c.writer1
              val bin_read_el_ : ('a, 'a el) Unsafe_read_c.reader1
            end
          module Make_iterable_binable1 :
            functor (Iterable_spec : Make_iterable_binable1_spec) ->
              sig
                val bin_size_t : ('a, 'a Iterable_spec.t) Size.sizer1
                val bin_write_t :
                  ('a, 'a Iterable_spec.t) Map_to_safe.writer1
                val bin_write_t_ :
                  ('a, 'a Iterable_spec.t) Unsafe_write_c.writer1
                val bin_read_t : ('a, 'a Iterable_spec.t) Map_to_safe.reader1
                val bin_read_t_ :
                  ('a, 'a Iterable_spec.t) Unsafe_read_c.reader1
                val bin_read_t__ :
                  ('a, int -> 'a Iterable_spec.t) Unsafe_read_c.reader1
                val bin_writer_t :
                  ('a, 'a Iterable_spec.t) Type_class.S1.writer
                val bin_reader_t :
                  ('a, 'a Iterable_spec.t) Type_class.S1.reader
                val bin_t : ('a, 'a Iterable_spec.t) Type_class.S1.t
              end
          module type Make_iterable_binable2_spec =
            sig
              type ('a, 'b) t
              type ('a, 'b) el
              type ('a, 'b) acc
              val module_name : string option
              val length : ('a, 'b) t -> int
              val iter : ('a, 'b) t -> f:(('a, 'b) el -> unit) -> unit
              val init : int -> ('a, 'b) acc
              val insert : ('a, 'b) acc -> ('a, 'b) el -> int -> ('a, 'b) acc
              val finish : ('a, 'b) acc -> ('a, 'b) t
              val bin_size_el : ('a, 'b, ('a, 'b) el) Size.sizer2
              val bin_write_el_ :
                ('a, 'b, ('a, 'b) el) Unsafe_write_c.writer2
              val bin_read_el_ : ('a, 'b, ('a, 'b) el) Unsafe_read_c.reader2
            end
          module Make_iterable_binable2 :
            functor (Iterable_spec : Make_iterable_binable2_spec) ->
              sig
                val bin_size_t :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Size.sizer2
                val bin_write_t :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Map_to_safe.writer2
                val bin_write_t_ :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Unsafe_write_c.writer2
                val bin_read_t :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Map_to_safe.reader2
                val bin_read_t_ :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Unsafe_read_c.reader2
                val bin_read_t__ :
                  ('a, 'b, int -> ('a, 'b) Iterable_spec.t)
                  Unsafe_read_c.reader2
                val bin_writer_t :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Type_class.S2.writer
                val bin_reader_t :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Type_class.S2.reader
                val bin_t :
                  ('a, 'b, ('a, 'b) Iterable_spec.t) Type_class.S2.t
              end
        end
      module Writer :
        sig
          type 'a t =
            'a Bin_prot.Type_class.writer = {
            size : 'a Size.sizer;
            write : 'a Write_ml.writer;
            unsafe_write : 'a Unsafe_write_c.writer;
          }
          val to_string : 'a t -> 'a -> string
        end
    end
  module Binary_packing :
    sig
      type endian = [ `Big_endian | `Little_endian ]
      val unpack_signed_8 : buf:string -> pos:int -> int
      val pack_signed_8 : buf:string -> pos:int -> int -> unit
      val unpack_unsigned_8 : buf:string -> pos:int -> int
      val pack_unsigned_8 : buf:string -> pos:int -> int -> unit
      val unpack_signed_16 :
        byte_order:endian -> buf:string -> pos:int -> int
      val pack_signed_16 :
        byte_order:endian -> buf:string -> pos:int -> int -> unit
      val unpack_unsigned_16_big_endian : buf:string -> pos:int -> int
      val unpack_unsigned_16_little_endian : buf:string -> pos:int -> int
      val pack_unsigned_16_big_endian : buf:string -> pos:int -> int -> unit
      val pack_unsigned_16_little_endian :
        buf:string -> pos:int -> int -> unit
      val unpack_signed_16_big_endian : buf:string -> pos:int -> int
      val unpack_signed_16_little_endian : buf:string -> pos:int -> int
      val pack_signed_16_big_endian : buf:string -> pos:int -> int -> unit
      val pack_signed_16_little_endian : buf:string -> pos:int -> int -> unit
      val unpack_unsigned_16 :
        byte_order:endian -> buf:string -> pos:int -> int
      val pack_unsigned_16 :
        byte_order:endian -> buf:string -> pos:int -> int -> unit
      val unpack_signed_32 :
        byte_order:endian -> buf:string -> pos:int -> int32
      val unpack_signed_32_int :
        byte_order:endian -> buf:string -> pos:int -> int
      val pack_signed_32 :
        byte_order:endian -> buf:string -> pos:int -> Int32.t -> unit
      val pack_signed_32_int :
        byte_order:endian -> buf:string -> pos:int -> int -> unit
      val unpack_unsigned_32_int_big_endian : buf:string -> pos:int -> int
      val unpack_unsigned_32_int_little_endian : buf:string -> pos:int -> int
      val pack_unsigned_32_int_big_endian :
        buf:string -> pos:int -> int -> unit
      val pack_unsigned_32_int_little_endian :
        buf:string -> pos:int -> int -> unit
      val unpack_signed_32_int_big_endian : buf:string -> pos:int -> int
      val unpack_signed_32_int_little_endian : buf:string -> pos:int -> int
      val pack_signed_32_int_big_endian :
        buf:string -> pos:int -> int -> unit
      val pack_signed_32_int_little_endian :
        buf:string -> pos:int -> int -> unit
      val unpack_unsigned_32_int :
        byte_order:endian -> buf:string -> pos:int -> int
      val pack_unsigned_32_int :
        byte_order:endian -> buf:string -> pos:int -> int -> unit
      val unpack_signed_64 :
        byte_order:endian -> buf:string -> pos:int -> int64
      val unpack_signed_64_int :
        byte_order:endian -> buf:string -> pos:int -> int
      val pack_signed_64 :
        byte_order:endian -> buf:string -> pos:int -> Int64.t -> unit
      val pack_signed_64_int :
        byte_order:endian -> buf:string -> pos:int -> int -> unit
      val unpack_signed_64_big_endian : buf:string -> pos:int -> int64
      val unpack_signed_64_little_endian : buf:string -> pos:int -> int64
      val pack_signed_64_big_endian : buf:string -> pos:int -> int64 -> unit
      val pack_signed_64_little_endian :
        buf:string -> pos:int -> int64 -> unit
      val unpack_float : byte_order:endian -> buf:string -> pos:int -> float
      val pack_float :
        byte_order:endian -> buf:string -> pos:int -> float -> unit
      val unpack_padded_fixed_string :
        ?padding:char -> buf:string -> pos:int -> len:int -> unit -> string
      val pack_padded_fixed_string :
        ?padding:char -> buf:string -> pos:int -> len:int -> string -> unit
      val test : unit -> unit
    end
  module Bool :
    sig
      type t = bool
      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 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 = Core_kernel.Bool.comparator
      val comparator : (t, comparator) Core_kernel.Comparator.t
      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
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val compare : t -> t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Bool.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val of_string : string -> t
      val to_string : t -> string
      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
  module Buffer :
    sig
      type t = Buffer.t
      val create : int -> t
      val contents : t -> string
      val sub : t -> int -> int -> string
      val blit : t -> int -> string -> int -> int -> unit
      val nth : t -> int -> char
      val length : t -> int
      val clear : t -> unit
      val reset : t -> unit
      val add_char : t -> char -> unit
      val add_string : t -> string -> unit
      val add_substring : t -> string -> int -> int -> unit
      val add_substitute : t -> (string -> string) -> string -> unit
      val add_buffer : t -> t -> unit
      val add_channel : t -> in_channel -> int -> unit
      val output_buffer : out_channel -> t -> unit
    end
  module Caml :
    sig
      module Arg :
        sig
          type spec =
            Arg.spec =
              Unit of (unit -> unit)
            | Bool of (bool -> unit)
            | Set of bool ref
            | Clear of bool ref
            | String of (string -> unit)
            | Set_string of string ref
            | Int of (int -> unit)
            | Set_int of int ref
            | Float of (float -> unit)
            | Set_float of float ref
            | Tuple of spec list
            | Symbol of string list * (string -> unit)
            | Rest of (string -> unit)
          type key = string
          type doc = string
          type usage_msg = string
          type anon_fun = string -> unit
          val parse :
            (key * spec * doc) list -> anon_fun -> usage_msg -> unit
          val parse_dynamic :
            (string * spec * string) list ref -> anon_fun -> string -> unit
          val parse_argv :
            ?current:int ref ->
            string array ->
            (key * spec * doc) list -> anon_fun -> usage_msg -> unit
          val parse_argv_dynamic :
            ?current:int ref ->
            string array ->
            (string * spec * string) list ref -> anon_fun -> string -> unit
          exception Help of string
          exception Bad of string
          val usage : (key * spec * doc) list -> usage_msg -> unit
          val usage_string : (key * spec * doc) list -> usage_msg -> string
          val align : (key * spec * doc) list -> (key * spec * doc) list
          val current : int ref
        end
      module Array :
        sig
          external length : 'a array -> int = "%array_length"
          external get : 'a array -> int -> 'a = "%array_safe_get"
          external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
          external make : int -> 'a -> 'a array = "caml_make_vect"
          external create : int -> 'a -> 'a array = "caml_make_vect"
          val init : int -> (int -> 'a) -> 'a array
          val make_matrix : int -> int -> 'a -> 'a array array
          val create_matrix : int -> int -> 'a -> 'a array array
          val append : 'a array -> 'a array -> 'a array
          val concat : 'a array list -> 'a array
          val sub : 'a array -> int -> int -> 'a array
          val copy : 'a array -> 'a array
          val fill : 'a array -> int -> int -> 'a -> unit
          val blit : 'a array -> int -> 'a array -> int -> int -> unit
          val to_list : 'a array -> 'a list
          val of_list : 'a list -> 'a array
          val iter : ('a -> unit) -> 'a array -> unit
          val map : ('a -> 'b) -> 'a array -> 'b array
          val iteri : (int -> 'a -> unit) -> 'a array -> unit
          val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
          val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
          val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
          val sort : ('a -> 'a -> int) -> 'a array -> unit
          val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
          val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
          external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
          external unsafe_set : 'a array -> int -> 'a -> unit
            = "%array_unsafe_set"
        end
      module ArrayLabels :
        sig
          external length : 'a array -> int = "%array_length"
          external get : 'a array -> int -> 'a = "%array_safe_get"
          external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
          external make : int -> 'a -> 'a array = "caml_make_vect"
          external create : int -> 'a -> 'a array = "caml_make_vect"
          val init : int -> f:(int -> 'a) -> 'a array
          val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
          val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
          val append : 'a array -> 'a array -> 'a array
          val concat : 'a array list -> 'a array
          val sub : 'a array -> pos:int -> len:int -> 'a array
          val copy : 'a array -> 'a array
          val fill : 'a array -> pos:int -> len:int -> 'a -> unit
          val blit :
            src:'a array ->
            src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit
          val to_list : 'a array -> 'a list
          val of_list : 'a list -> 'a array
          val iter : f:('a -> unit) -> 'a array -> unit
          val map : f:('a -> 'b) -> 'a array -> 'b array
          val iteri : f:(int -> 'a -> unit) -> 'a array -> unit
          val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array
          val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a
          val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a
          val sort : cmp:('a -> 'a -> int) -> 'a array -> unit
          val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
          val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
          external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
          external unsafe_set : 'a array -> int -> 'a -> unit
            = "%array_unsafe_set"
        end
      module Buffer :
        sig
          type t = Buffer.t
          val create : int -> t
          val contents : t -> string
          val sub : t -> int -> int -> string
          val blit : t -> int -> string -> int -> int -> unit
          val nth : t -> int -> char
          val length : t -> int
          val clear : t -> unit
          val reset : t -> unit
          val add_char : t -> char -> unit
          val add_string : t -> string -> unit
          val add_substring : t -> string -> int -> int -> unit
          val add_substitute : t -> (string -> string) -> string -> unit
          val add_buffer : t -> t -> unit
          val add_channel : t -> in_channel -> int -> unit
          val output_buffer : out_channel -> t -> unit
        end
      module Callback :
        sig
          val register : string -> 'a -> unit
          val register_exception : string -> exn -> unit
        end
      module Char :
        sig
          external code : char -> int = "%identity"
          val chr : int -> char
          val escaped : char -> string
          val lowercase : char -> char
          val uppercase : char -> char
          type t = char
          val compare : t -> t -> int
          external unsafe_chr : int -> char = "%identity"
        end
      module Complex :
        sig
          type t = Complex.t = { re : float; im : float; }
          val zero : t
          val one : t
          val i : t
          val neg : t -> t
          val conj : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val inv : t -> t
          val div : t -> t -> t
          val sqrt : t -> t
          val norm2 : t -> float
          val norm : t -> float
          val arg : t -> float
          val polar : float -> float -> t
          val exp : t -> t
          val log : t -> t
          val pow : t -> t -> t
        end
      module Digest :
        sig
          type t = string
          val compare : t -> t -> int
          val string : string -> t
          val substring : string -> int -> int -> t
          external channel : in_channel -> int -> t = "caml_md5_chan"
          val file : string -> t
          val output : out_channel -> t -> unit
          val input : in_channel -> t
          val to_hex : t -> string
          val from_hex : string -> t
        end
      module Filename :
        sig
          val current_dir_name : string
          val parent_dir_name : string
          val dir_sep : string
          val concat : string -> string -> string
          val is_relative : string -> bool
          val is_implicit : string -> bool
          val check_suffix : string -> string -> bool
          val chop_suffix : string -> string -> string
          val chop_extension : string -> string
          val basename : string -> string
          val dirname : string -> string
          val temp_file : ?temp_dir:string -> string -> string -> string
          val open_temp_file :
            ?mode:open_flag list ->
            ?temp_dir:string -> string -> string -> string * out_channel
          val get_temp_dir_name : unit -> string
          val set_temp_dir_name : string -> unit
          val temp_dir_name : string
          val quote : string -> string
        end
      module Format :
        sig
          val open_box : int -> unit
          val close_box : unit -> unit
          val print_string : string -> unit
          val print_as : int -> string -> unit
          val print_int : int -> unit
          val print_float : float -> unit
          val print_char : char -> unit
          val print_bool : bool -> unit
          val print_space : unit -> unit
          val print_cut : unit -> unit
          val print_break : int -> int -> unit
          val print_flush : unit -> unit
          val print_newline : unit -> unit
          val force_newline : unit -> unit
          val print_if_newline : unit -> unit
          val set_margin : int -> unit
          val get_margin : unit -> int
          val set_max_indent : int -> unit
          val get_max_indent : unit -> int
          val set_max_boxes : int -> unit
          val get_max_boxes : unit -> int
          val over_max_boxes : unit -> bool
          val open_hbox : unit -> unit
          val open_vbox : int -> unit
          val open_hvbox : int -> unit
          val open_hovbox : int -> unit
          val open_tbox : unit -> unit
          val close_tbox : unit -> unit
          val print_tbreak : int -> int -> unit
          val set_tab : unit -> unit
          val print_tab : unit -> unit
          val set_ellipsis_text : string -> unit
          val get_ellipsis_text : unit -> string
          type tag = string
          val open_tag : tag -> unit
          val close_tag : unit -> unit
          val set_tags : bool -> unit
          val set_print_tags : bool -> unit
          val set_mark_tags : bool -> unit
          val get_print_tags : unit -> bool
          val get_mark_tags : unit -> bool
          val set_formatter_out_channel : out_channel -> unit
          val set_formatter_output_functions :
            (string -> int -> int -> unit) -> (unit -> unit) -> unit
          val get_formatter_output_functions :
            unit -> (string -> int -> int -> unit) * (unit -> unit)
          type formatter_out_functions =
            Format.formatter_out_functions = {
            out_string : string -> int -> int -> unit;
            out_flush : unit -> unit;
            out_newline : unit -> unit;
            out_spaces : int -> unit;
          }
          val set_formatter_out_functions : formatter_out_functions -> unit
          val get_formatter_out_functions : unit -> formatter_out_functions
          type formatter_tag_functions =
            Format.formatter_tag_functions = {
            mark_open_tag : tag -> string;
            mark_close_tag : tag -> string;
            print_open_tag : tag -> unit;
            print_close_tag : tag -> unit;
          }
          val set_formatter_tag_functions : formatter_tag_functions -> unit
          val get_formatter_tag_functions : unit -> formatter_tag_functions
          type formatter = Format.formatter
          val formatter_of_out_channel : out_channel -> formatter
          val std_formatter : formatter
          val err_formatter : formatter
          val formatter_of_buffer : Buffer.t -> formatter
          val stdbuf : Buffer.t
          val str_formatter : formatter
          val flush_str_formatter : unit -> string
          val make_formatter :
            (string -> int -> int -> unit) -> (unit -> unit) -> formatter
          val pp_open_hbox : formatter -> unit -> unit
          val pp_open_vbox : formatter -> int -> unit
          val pp_open_hvbox : formatter -> int -> unit
          val pp_open_hovbox : formatter -> int -> unit
          val pp_open_box : formatter -> int -> unit
          val pp_close_box : formatter -> unit -> unit
          val pp_open_tag : formatter -> string -> unit
          val pp_close_tag : formatter -> unit -> unit
          val pp_print_string : formatter -> string -> unit
          val pp_print_as : formatter -> int -> string -> unit
          val pp_print_int : formatter -> int -> unit
          val pp_print_float : formatter -> float -> unit
          val pp_print_char : formatter -> char -> unit
          val pp_print_bool : formatter -> bool -> unit
          val pp_print_break : formatter -> int -> int -> unit
          val pp_print_cut : formatter -> unit -> unit
          val pp_print_space : formatter -> unit -> unit
          val pp_force_newline : formatter -> unit -> unit
          val pp_print_flush : formatter -> unit -> unit
          val pp_print_newline : formatter -> unit -> unit
          val pp_print_if_newline : formatter -> unit -> unit
          val pp_open_tbox : formatter -> unit -> unit
          val pp_close_tbox : formatter -> unit -> unit
          val pp_print_tbreak : formatter -> int -> int -> unit
          val pp_set_tab : formatter -> unit -> unit
          val pp_print_tab : formatter -> unit -> unit
          val pp_set_tags : formatter -> bool -> unit
          val pp_set_print_tags : formatter -> bool -> unit
          val pp_set_mark_tags : formatter -> bool -> unit
          val pp_get_print_tags : formatter -> unit -> bool
          val pp_get_mark_tags : formatter -> unit -> bool
          val pp_set_margin : formatter -> int -> unit
          val pp_get_margin : formatter -> unit -> int
          val pp_set_max_indent : formatter -> int -> unit
          val pp_get_max_indent : formatter -> unit -> int
          val pp_set_max_boxes : formatter -> int -> unit
          val pp_get_max_boxes : formatter -> unit -> int
          val pp_over_max_boxes : formatter -> unit -> bool
          val pp_set_ellipsis_text : formatter -> string -> unit
          val pp_get_ellipsis_text : formatter -> unit -> string
          val pp_set_formatter_out_channel : formatter -> out_channel -> unit
          val pp_set_formatter_output_functions :
            formatter ->
            (string -> int -> int -> unit) -> (unit -> unit) -> unit
          val pp_get_formatter_output_functions :
            formatter ->
            unit -> (string -> int -> int -> unit) * (unit -> unit)
          val pp_set_formatter_tag_functions :
            formatter -> formatter_tag_functions -> unit
          val pp_get_formatter_tag_functions :
            formatter -> unit -> formatter_tag_functions
          val pp_set_formatter_out_functions :
            formatter -> formatter_out_functions -> unit
          val pp_get_formatter_out_functions :
            formatter -> unit -> formatter_out_functions
          val fprintf : formatter -> ('a, formatter, unit) format -> 'a
          val printf : ('a, formatter, unit) format -> 'a
          val eprintf : ('a, formatter, unit) format -> 'a
          val sprintf : ('a, unit, string) format -> 'a
          val asprintf : ('a, formatter, unit, string) format4 -> 'a
          val ifprintf : formatter -> ('a, formatter, unit) format -> 'a
          val kfprintf :
            (formatter -> 'a) ->
            formatter -> ('b, formatter, unit, 'a) format4 -> 'b
          val ikfprintf :
            (formatter -> 'a) ->
            formatter -> ('b, formatter, unit, 'a) format4 -> 'b
          val ksprintf :
            (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
          val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a
          val kprintf :
            (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
          val set_all_formatter_output_functions :
            out:(string -> int -> int -> unit) ->
            flush:(unit -> unit) ->
            newline:(unit -> unit) -> spaces:(int -> unit) -> unit
          val get_all_formatter_output_functions :
            unit ->
            (string -> int -> int -> unit) * (unit -> unit) *
            (unit -> unit) * (int -> unit)
          val pp_set_all_formatter_output_functions :
            formatter ->
            out:(string -> int -> int -> unit) ->
            flush:(unit -> unit) ->
            newline:(unit -> unit) -> spaces:(int -> unit) -> unit
          val pp_get_all_formatter_output_functions :
            formatter ->
            unit ->
            (string -> int -> int -> unit) * (unit -> unit) *
            (unit -> unit) * (int -> unit)
        end
      module Gc :
        sig
          type stat =
            Gc.stat = {
            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;
          }
          type control =
            Gc.control = {
            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;
          }
          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
        end
      module Genlex :
        sig
          type token =
            Genlex.token =
              Kwd of string
            | Ident of string
            | Int of int
            | Float of float
            | String of string
            | Char of char
          val make_lexer : string list -> char Stream.t -> token Stream.t
        end
      module Hashtbl :
        sig
          type ('a, 'b) t = ('a, 'b) Hashtbl.t
          val create : ?random:bool -> int -> ('a, 'b) t
          val clear : ('a, 'b) t -> unit
          val reset : ('a, 'b) t -> unit
          val copy : ('a, 'b) t -> ('a, 'b) t
          val add : ('a, 'b) t -> 'a -> 'b -> unit
          val find : ('a, 'b) t -> 'a -> 'b
          val find_all : ('a, 'b) t -> 'a -> 'b list
          val mem : ('a, 'b) t -> 'a -> bool
          val remove : ('a, 'b) t -> 'a -> unit
          val replace : ('a, 'b) t -> 'a -> 'b -> unit
          val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
          val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
          val length : ('a, 'b) t -> int
          val randomize : unit -> unit
          type statistics =
            Hashtbl.statistics = {
            num_bindings : int;
            num_buckets : int;
            max_bucket_length : int;
            bucket_histogram : int array;
          }
          val stats : ('a, 'b) t -> statistics
          module type HashedType =
            sig type t val equal : t -> t -> bool val hash : t -> int end
          module type S =
            sig
              type key
              type 'a t
              val create : int -> 'a t
              val clear : 'a t -> unit
              val reset : 'a t -> unit
              val copy : 'a t -> 'a t
              val add : 'a t -> key -> 'a -> unit
              val remove : 'a t -> key -> unit
              val find : 'a t -> key -> 'a
              val find_all : 'a t -> key -> 'a list
              val replace : 'a t -> key -> 'a -> unit
              val mem : 'a t -> key -> bool
              val iter : (key -> 'a -> unit) -> 'a t -> unit
              val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
              val length : 'a t -> int
              val stats : 'a t -> statistics
            end
          module Make :
            functor (H : HashedType) ->
              sig
                type key = H.t
                type 'a t = 'a Hashtbl.Make(H).t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val reset : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> 'a -> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> 'a -> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> 'a -> unit) -> 'a t -> unit
                val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
                val length : 'a t -> int
                val stats : 'a t -> statistics
              end
          module type SeededHashedType =
            sig
              type t
              val equal : t -> t -> bool
              val hash : int -> t -> int
            end
          module type SeededS =
            sig
              type key
              type 'a t
              val create : ?random:bool -> int -> 'a t
              val clear : 'a t -> unit
              val reset : 'a t -> unit
              val copy : 'a t -> 'a t
              val add : 'a t -> key -> 'a -> unit
              val remove : 'a t -> key -> unit
              val find : 'a t -> key -> 'a
              val find_all : 'a t -> key -> 'a list
              val replace : 'a t -> key -> 'a -> unit
              val mem : 'a t -> key -> bool
              val iter : (key -> 'a -> unit) -> 'a t -> unit
              val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
              val length : 'a t -> int
              val stats : 'a t -> statistics
            end
          module MakeSeeded :
            functor (H : SeededHashedType) ->
              sig
                type key = H.t
                type 'a t = 'a Hashtbl.MakeSeeded(H).t
                val create : ?random:bool -> int -> 'a t
                val clear : 'a t -> unit
                val reset : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> 'a -> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> 'a -> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> 'a -> unit) -> 'a t -> unit
                val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
                val length : 'a t -> int
                val stats : 'a t -> statistics
              end
          val hash : 'a -> int
          val seeded_hash : int -> 'a -> int
          val hash_param : int -> int -> 'a -> int
          val seeded_hash_param : int -> int -> int -> 'a -> int
        end
      module Int32 :
        sig
          val zero : int32
          val one : int32
          val minus_one : int32
          external neg : int32 -> int32 = "%int32_neg"
          external add : int32 -> int32 -> int32 = "%int32_add"
          external sub : int32 -> int32 -> int32 = "%int32_sub"
          external mul : int32 -> int32 -> int32 = "%int32_mul"
          external div : int32 -> int32 -> int32 = "%int32_div"
          external rem : int32 -> int32 -> int32 = "%int32_mod"
          val succ : int32 -> int32
          val pred : int32 -> int32
          val abs : int32 -> int32
          val max_int : int32
          val min_int : int32
          external logand : int32 -> int32 -> int32 = "%int32_and"
          external logor : int32 -> int32 -> int32 = "%int32_or"
          external logxor : int32 -> int32 -> int32 = "%int32_xor"
          val lognot : int32 -> int32
          external shift_left : int32 -> int -> int32 = "%int32_lsl"
          external shift_right : int32 -> int -> int32 = "%int32_asr"
          external shift_right_logical : int32 -> int -> int32 = "%int32_lsr"
          external of_int : int -> int32 = "%int32_of_int"
          external to_int : int32 -> int = "%int32_to_int"
          external of_float : float -> int32 = "caml_int32_of_float"
          external to_float : int32 -> float = "caml_int32_to_float"
          external of_string : string -> int32 = "caml_int32_of_string"
          val to_string : int32 -> string
          external bits_of_float : float -> int32
            = "caml_int32_bits_of_float"
          external float_of_bits : int32 -> float
            = "caml_int32_float_of_bits"
          type t = int32
          val compare : t -> t -> int
          external format : string -> int32 -> string = "caml_int32_format"
        end
      module Int64 :
        sig
          val zero : int64
          val one : int64
          val minus_one : int64
          external neg : int64 -> int64 = "%int64_neg"
          external add : int64 -> int64 -> int64 = "%int64_add"
          external sub : int64 -> int64 -> int64 = "%int64_sub"
          external mul : int64 -> int64 -> int64 = "%int64_mul"
          external div : int64 -> int64 -> int64 = "%int64_div"
          external rem : int64 -> int64 -> int64 = "%int64_mod"
          val succ : int64 -> int64
          val pred : int64 -> int64
          val abs : int64 -> int64
          val max_int : int64
          val min_int : int64
          external logand : int64 -> int64 -> int64 = "%int64_and"
          external logor : int64 -> int64 -> int64 = "%int64_or"
          external logxor : int64 -> int64 -> int64 = "%int64_xor"
          val lognot : int64 -> int64
          external shift_left : int64 -> int -> int64 = "%int64_lsl"
          external shift_right : int64 -> int -> int64 = "%int64_asr"
          external shift_right_logical : int64 -> int -> int64 = "%int64_lsr"
          external of_int : int -> int64 = "%int64_of_int"
          external to_int : int64 -> int = "%int64_to_int"
          external of_float : float -> int64 = "caml_int64_of_float"
          external to_float : int64 -> float = "caml_int64_to_float"
          external of_int32 : int32 -> int64 = "%int64_of_int32"
          external to_int32 : int64 -> int32 = "%int64_to_int32"
          external of_nativeint : nativeint -> int64 = "%int64_of_nativeint"
          external to_nativeint : int64 -> nativeint = "%int64_to_nativeint"
          external of_string : string -> int64 = "caml_int64_of_string"
          val to_string : int64 -> string
          external bits_of_float : float -> int64
            = "caml_int64_bits_of_float"
          external float_of_bits : int64 -> float
            = "caml_int64_float_of_bits"
          type t = int64
          val compare : t -> t -> int
          external format : string -> int64 -> string = "caml_int64_format"
        end
      module Lazy :
        sig
          type 'a t = 'a lazy_t
          exception Undefined
          external force : 'a t -> 'a = "%lazy_force"
          val force_val : 'a t -> 'a
          val from_fun : (unit -> 'a) -> 'a t
          val from_val : 'a -> 'a t
          val is_val : 'a t -> bool
          val lazy_from_fun : (unit -> 'a) -> 'a t
          val lazy_from_val : 'a -> 'a t
          val lazy_is_val : 'a t -> bool
        end
      module Lexing :
        sig
          type position =
            Lexing.position = {
            pos_fname : string;
            pos_lnum : int;
            pos_bol : int;
            pos_cnum : int;
          }
          val dummy_pos : position
          type lexbuf =
            Lexing.lexbuf = {
            refill_buff : lexbuf -> unit;
            mutable lex_buffer : string;
            mutable lex_buffer_len : int;
            mutable lex_abs_pos : int;
            mutable lex_start_pos : int;
            mutable lex_curr_pos : int;
            mutable lex_last_pos : int;
            mutable lex_last_action : int;
            mutable lex_eof_reached : bool;
            mutable lex_mem : int array;
            mutable lex_start_p : position;
            mutable lex_curr_p : position;
          }
          val from_channel : in_channel -> lexbuf
          val from_string : string -> lexbuf
          val from_function : (string -> int -> int) -> lexbuf
          val lexeme : lexbuf -> string
          val lexeme_char : lexbuf -> int -> char
          val lexeme_start : lexbuf -> int
          val lexeme_end : lexbuf -> int
          val lexeme_start_p : lexbuf -> position
          val lexeme_end_p : lexbuf -> position
          val new_line : lexbuf -> unit
          val flush_input : lexbuf -> unit
          val sub_lexeme : lexbuf -> int -> int -> string
          val sub_lexeme_opt : lexbuf -> int -> int -> string option
          val sub_lexeme_char : lexbuf -> int -> char
          val sub_lexeme_char_opt : lexbuf -> int -> char option
          type lex_tables =
            Lexing.lex_tables = {
            lex_base : string;
            lex_backtrk : string;
            lex_default : string;
            lex_trans : string;
            lex_check : string;
            lex_base_code : string;
            lex_backtrk_code : string;
            lex_default_code : string;
            lex_trans_code : string;
            lex_check_code : string;
            lex_code : string;
          }
          val engine : lex_tables -> int -> lexbuf -> int
          val new_engine : lex_tables -> int -> lexbuf -> int
        end
      module List :
        sig
          val length : 'a list -> int
          val hd : 'a list -> 'a
          val tl : 'a list -> 'a list
          val nth : 'a list -> int -> 'a
          val rev : 'a list -> 'a list
          val append : 'a list -> 'a list -> 'a list
          val rev_append : 'a list -> 'a list -> 'a list
          val concat : 'a list list -> 'a list
          val flatten : 'a list list -> 'a list
          val iter : ('a -> unit) -> 'a list -> unit
          val iteri : (int -> 'a -> unit) -> 'a list -> unit
          val map : ('a -> 'b) -> 'a list -> 'b list
          val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
          val rev_map : ('a -> 'b) -> 'a list -> 'b list
          val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
          val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
          val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
          val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
          val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
          val fold_left2 :
            ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
          val fold_right2 :
            ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
          val for_all : ('a -> bool) -> 'a list -> bool
          val exists : ('a -> bool) -> 'a list -> bool
          val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
          val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
          val mem : 'a -> 'a list -> bool
          val memq : 'a -> 'a list -> bool
          val find : ('a -> bool) -> 'a list -> 'a
          val filter : ('a -> bool) -> 'a list -> 'a list
          val find_all : ('a -> bool) -> 'a list -> 'a list
          val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
          val assoc : 'a -> ('a * 'b) list -> 'b
          val assq : 'a -> ('a * 'b) list -> 'b
          val mem_assoc : 'a -> ('a * 'b) list -> bool
          val mem_assq : 'a -> ('a * 'b) list -> bool
          val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
          val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
          val split : ('a * 'b) list -> 'a list * 'b list
          val combine : 'a list -> 'b list -> ('a * 'b) list
          val sort : ('a -> 'a -> int) -> 'a list -> 'a list
          val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list
          val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list
          val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
        end
      module ListLabels :
        sig
          val length : 'a list -> int
          val hd : 'a list -> 'a
          val tl : 'a list -> 'a list
          val nth : 'a list -> int -> 'a
          val rev : 'a list -> 'a list
          val append : 'a list -> 'a list -> 'a list
          val rev_append : 'a list -> 'a list -> 'a list
          val concat : 'a list list -> 'a list
          val flatten : 'a list list -> 'a list
          val iter : f:('a -> unit) -> 'a list -> unit
          val iteri : f:(int -> 'a -> unit) -> 'a list -> unit
          val map : f:('a -> 'b) -> 'a list -> 'b list
          val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list
          val rev_map : f:('a -> 'b) -> 'a list -> 'b list
          val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a
          val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b
          val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
          val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
          val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
          val fold_left2 :
            f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a
          val fold_right2 :
            f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c
          val for_all : f:('a -> bool) -> 'a list -> bool
          val exists : f:('a -> bool) -> 'a list -> bool
          val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
          val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
          val mem : 'a -> set:'a list -> bool
          val memq : 'a -> set:'a list -> bool
          val find : f:('a -> bool) -> 'a list -> 'a
          val filter : f:('a -> bool) -> 'a list -> 'a list
          val find_all : f:('a -> bool) -> 'a list -> 'a list
          val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
          val assoc : 'a -> ('a * 'b) list -> 'b
          val assq : 'a -> ('a * 'b) list -> 'b
          val mem_assoc : 'a -> map:('a * 'b) list -> bool
          val mem_assq : 'a -> map:('a * 'b) list -> bool
          val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
          val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
          val split : ('a * 'b) list -> 'a list * 'b list
          val combine : 'a list -> 'b list -> ('a * 'b) list
          val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
          val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
          val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
          val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
        end
      module Map :
        sig
          module type OrderedType =
            sig type t val compare : t -> t -> int end
          module type S =
            sig
              type key
              type +'a t
              val empty : 'a t
              val is_empty : 'a t -> bool
              val mem : key -> 'a t -> bool
              val add : key -> 'a -> 'a t -> 'a t
              val singleton : key -> 'a -> 'a t
              val remove : key -> 'a t -> 'a t
              val merge :
                (key -> 'a option -> 'b option -> 'c option) ->
                'a t -> 'b t -> 'c t
              val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
              val iter : (key -> 'a -> unit) -> 'a t -> unit
              val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
              val for_all : (key -> 'a -> bool) -> 'a t -> bool
              val exists : (key -> 'a -> bool) -> 'a t -> bool
              val filter : (key -> 'a -> bool) -> 'a t -> 'a t
              val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
              val cardinal : 'a t -> int
              val bindings : 'a t -> (key * 'a) list
              val min_binding : 'a t -> key * 'a
              val max_binding : 'a t -> key * 'a
              val choose : 'a t -> key * 'a
              val split : key -> 'a t -> 'a t * 'a option * 'a t
              val find : key -> 'a t -> 'a
              val map : ('a -> 'b) -> 'a t -> 'b t
              val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            end
          module Make :
            functor (Ord : OrderedType) ->
              sig
                type key = Ord.t
                type 'a t = 'a Map.Make(Ord).t
                val empty : 'a t
                val is_empty : 'a t -> bool
                val mem : key -> 'a t -> bool
                val add : key -> 'a -> 'a t -> 'a t
                val singleton : key -> 'a -> 'a t
                val remove : key -> 'a t -> 'a t
                val merge :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val iter : (key -> 'a -> unit) -> 'a t -> unit
                val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
                val for_all : (key -> 'a -> bool) -> 'a t -> bool
                val exists : (key -> 'a -> bool) -> 'a t -> bool
                val filter : (key -> 'a -> bool) -> 'a t -> 'a t
                val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
                val cardinal : 'a t -> int
                val bindings : 'a t -> (key * 'a) list
                val min_binding : 'a t -> key * 'a
                val max_binding : 'a t -> key * 'a
                val choose : 'a t -> key * 'a
                val split : key -> 'a t -> 'a t * 'a option * 'a t
                val find : key -> 'a t -> 'a
                val map : ('a -> 'b) -> 'a t -> 'b t
                val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
              end
        end
      module Marshal :
        sig
          type extern_flags =
            Marshal.extern_flags =
              No_sharing
            | Closures
            | Compat_32
          val to_channel : out_channel -> 'a -> extern_flags list -> unit
          external to_string : 'a -> extern_flags list -> string
            = "caml_output_value_to_string"
          val to_buffer :
            string -> int -> int -> 'a -> extern_flags list -> int
          val from_channel : in_channel -> 'a
          val from_string : string -> int -> 'a
          val header_size : int
          val data_size : string -> int -> int
          val total_size : string -> int -> int
        end
      module MoreLabels :
        sig
          module Hashtbl :
            sig
              type ('a, 'b) t = ('a, 'b) Hashtbl.t
              val create : ?random:bool -> int -> ('a, 'b) t
              val clear : ('a, 'b) t -> unit
              val reset : ('a, 'b) t -> unit
              val copy : ('a, 'b) t -> ('a, 'b) t
              val add : ('a, 'b) t -> key:'a -> data:'b -> unit
              val find : ('a, 'b) t -> 'a -> 'b
              val find_all : ('a, 'b) t -> 'a -> 'b list
              val mem : ('a, 'b) t -> 'a -> bool
              val remove : ('a, 'b) t -> 'a -> unit
              val replace : ('a, 'b) t -> key:'a -> data:'b -> unit
              val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit
              val fold :
                f:(key:'a -> data:'b -> 'c -> 'c) ->
                ('a, 'b) t -> init:'c -> 'c
              val length : ('a, 'b) t -> int
              val randomize : unit -> unit
              type statistics = Hashtbl.statistics
              val stats : ('a, 'b) t -> statistics
              module type HashedType = Hashtbl.HashedType
              module type SeededHashedType = Hashtbl.SeededHashedType
              module type S =
                sig
                  type key
                  and 'a t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val reset : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key:key -> data:'a -> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key:key -> data:'a -> unit
                  val mem : 'a t -> key -> bool
                  val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
                  val fold :
                    f:(key:key -> data:'a -> 'b -> 'b) ->
                    'a t -> init:'b -> 'b
                  val length : 'a t -> int
                  val stats : 'a t -> statistics
                end
              module type SeededS =
                sig
                  type key
                  and 'a t
                  val create : ?random:bool -> int -> 'a t
                  val clear : 'a t -> unit
                  val reset : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key:key -> data:'a -> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key:key -> data:'a -> unit
                  val mem : 'a t -> key -> bool
                  val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
                  val fold :
                    f:(key:key -> data:'a -> 'b -> 'b) ->
                    'a t -> init:'b -> 'b
                  val length : 'a t -> int
                  val stats : 'a t -> statistics
                end
              module Make :
                functor (H : HashedType) ->
                  sig
                    type key = H.t
                    and 'a t = 'a MoreLabels.Hashtbl.Make(H).t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val reset : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key:key -> data:'a -> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key:key -> data:'a -> unit
                    val mem : 'a t -> key -> bool
                    val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
                    val fold :
                      f:(key:key -> data:'a -> 'b -> 'b) ->
                      'a t -> init:'b -> 'b
                    val length : 'a t -> int
                    val stats : 'a t -> statistics
                  end
              module MakeSeeded :
                functor (H : SeededHashedType) ->
                  sig
                    type key = H.t
                    and 'a t = 'a MoreLabels.Hashtbl.MakeSeeded(H).t
                    val create : ?random:bool -> int -> 'a t
                    val clear : 'a t -> unit
                    val reset : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key:key -> data:'a -> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key:key -> data:'a -> unit
                    val mem : 'a t -> key -> bool
                    val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
                    val fold :
                      f:(key:key -> data:'a -> 'b -> 'b) ->
                      'a t -> init:'b -> 'b
                    val length : 'a t -> int
                    val stats : 'a t -> statistics
                  end
              val hash : 'a -> int
              val seeded_hash : int -> 'a -> int
              val hash_param : int -> int -> 'a -> int
              val seeded_hash_param : int -> int -> int -> 'a -> int
            end
          module Map :
            sig
              module type OrderedType = Map.OrderedType
              module type S =
                sig
                  type key
                  and +'a t
                  val empty : 'a t
                  val is_empty : 'a t -> bool
                  val mem : key -> 'a t -> bool
                  val add : key:key -> data:'a -> 'a t -> 'a t
                  val singleton : key -> 'a -> 'a t
                  val remove : key -> 'a t -> 'a t
                  val merge :
                    f:(key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
                  val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                  val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
                  val fold :
                    f:(key:key -> data:'a -> 'b -> 'b) ->
                    'a t -> init:'b -> 'b
                  val for_all : f:(key -> 'a -> bool) -> 'a t -> bool
                  val exists : f:(key -> 'a -> bool) -> 'a t -> bool
                  val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t
                  val partition :
                    f:(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
                  val cardinal : 'a t -> int
                  val bindings : 'a t -> (key * 'a) list
                  val min_binding : 'a t -> key * 'a
                  val max_binding : 'a t -> key * 'a
                  val choose : 'a t -> key * 'a
                  val split : key -> 'a t -> 'a t * 'a option * 'a t
                  val find : key -> 'a t -> 'a
                  val map : f:('a -> 'b) -> 'a t -> 'b t
                  val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
                end
              module Make :
                functor (Ord : OrderedType) ->
                  sig
                    type key = Ord.t
                    and 'a t = 'a MoreLabels.Map.Make(Ord).t
                    val empty : 'a t
                    val is_empty : 'a t -> bool
                    val mem : key -> 'a t -> bool
                    val add : key:key -> data:'a -> 'a t -> 'a t
                    val singleton : key -> 'a -> 'a t
                    val remove : key -> 'a t -> 'a t
                    val merge :
                      f:(key -> 'a option -> 'b option -> 'c option) ->
                      'a t -> 'b t -> 'c t
                    val compare :
                      cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal :
                      cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
                    val fold :
                      f:(key:key -> data:'a -> 'b -> 'b) ->
                      'a t -> init:'b -> 'b
                    val for_all : f:(key -> 'a -> bool) -> 'a t -> bool
                    val exists : f:(key -> 'a -> bool) -> 'a t -> bool
                    val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t
                    val partition :
                      f:(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
                    val cardinal : 'a t -> int
                    val bindings : 'a t -> (key * 'a) list
                    val min_binding : 'a t -> key * 'a
                    val max_binding : 'a t -> key * 'a
                    val choose : 'a t -> key * 'a
                    val split : key -> 'a t -> 'a t * 'a option * 'a t
                    val find : key -> 'a t -> 'a
                    val map : f:('a -> 'b) -> 'a t -> 'b t
                    val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
                  end
            end
          module Set :
            sig
              module type OrderedType = Set.OrderedType
              module type S =
                sig
                  type elt
                  and t
                  val empty : t
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val remove : elt -> t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val compare : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val iter : f:(elt -> unit) -> t -> unit
                  val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
                  val for_all : f:(elt -> bool) -> t -> bool
                  val exists : f:(elt -> bool) -> t -> bool
                  val filter : f:(elt -> bool) -> t -> t
                  val partition : f:(elt -> bool) -> t -> t * t
                  val cardinal : t -> int
                  val elements : t -> elt list
                  val min_elt : t -> elt
                  val max_elt : t -> elt
                  val choose : t -> elt
                  val split : elt -> t -> t * bool * t
                  val find : elt -> t -> elt
                end
              module Make :
                functor (Ord : OrderedType) ->
                  sig
                    type elt = Ord.t
                    and t = MoreLabels.Set.Make(Ord).t
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : f:(elt -> unit) -> t -> unit
                    val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
                    val for_all : f:(elt -> bool) -> t -> bool
                    val exists : f:(elt -> bool) -> t -> bool
                    val filter : f:(elt -> bool) -> t -> t
                    val partition : f:(elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val split : elt -> t -> t * bool * t
                    val find : elt -> t -> elt
                  end
            end
        end
      module Nativeint :
        sig
          val zero : nativeint
          val one : nativeint
          val minus_one : nativeint
          external neg : nativeint -> nativeint = "%nativeint_neg"
          external add : nativeint -> nativeint -> nativeint
            = "%nativeint_add"
          external sub : nativeint -> nativeint -> nativeint
            = "%nativeint_sub"
          external mul : nativeint -> nativeint -> nativeint
            = "%nativeint_mul"
          external div : nativeint -> nativeint -> nativeint
            = "%nativeint_div"
          external rem : nativeint -> nativeint -> nativeint
            = "%nativeint_mod"
          val succ : nativeint -> nativeint
          val pred : nativeint -> nativeint
          val abs : nativeint -> nativeint
          val size : int
          val max_int : nativeint
          val min_int : nativeint
          external logand : nativeint -> nativeint -> nativeint
            = "%nativeint_and"
          external logor : nativeint -> nativeint -> nativeint
            = "%nativeint_or"
          external logxor : nativeint -> nativeint -> nativeint
            = "%nativeint_xor"
          val lognot : nativeint -> nativeint
          external shift_left : nativeint -> int -> nativeint
            = "%nativeint_lsl"
          external shift_right : nativeint -> int -> nativeint
            = "%nativeint_asr"
          external shift_right_logical : nativeint -> int -> nativeint
            = "%nativeint_lsr"
          external of_int : int -> nativeint = "%nativeint_of_int"
          external to_int : nativeint -> int = "%nativeint_to_int"
          external of_float : float -> nativeint = "caml_nativeint_of_float"
          external to_float : nativeint -> float = "caml_nativeint_to_float"
          external of_int32 : int32 -> nativeint = "%nativeint_of_int32"
          external to_int32 : nativeint -> int32 = "%nativeint_to_int32"
          external of_string : string -> nativeint
            = "caml_nativeint_of_string"
          val to_string : nativeint -> string
          type t = nativeint
          val compare : t -> t -> int
          external format : string -> nativeint -> string
            = "caml_nativeint_format"
        end
      module Oo :
        sig
          val copy : (< .. > as 'a) -> 'a
          external id : < .. > -> int = "%field1"
          val new_method : string -> CamlinternalOO.tag
          val public_method_label : string -> CamlinternalOO.tag
        end
      module Parsing :
        sig
          val symbol_start : unit -> int
          val symbol_end : unit -> int
          val rhs_start : int -> int
          val rhs_end : int -> int
          val symbol_start_pos : unit -> Lexing.position
          val symbol_end_pos : unit -> Lexing.position
          val rhs_start_pos : int -> Lexing.position
          val rhs_end_pos : int -> Lexing.position
          val clear_parser : unit -> unit
          exception Parse_error
          val set_trace : bool -> bool
          type parser_env = Parsing.parser_env
          type parse_tables =
            Parsing.parse_tables = {
            actions : (parser_env -> Obj.t) array;
            transl_const : int array;
            transl_block : int array;
            lhs : string;
            len : string;
            defred : string;
            dgoto : string;
            sindex : string;
            rindex : string;
            gindex : string;
            tablesize : int;
            table : string;
            check : string;
            error_function : string -> unit;
            names_const : string;
            names_block : string;
          }
          exception YYexit of Obj.t
          val yyparse :
            parse_tables ->
            int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b
          val peek_val : parser_env -> int -> 'a
          val is_current_lookahead : 'a -> bool
          val parse_error : string -> unit
        end
      module Pervasives :
        sig
          external raise : exn -> 'a = "%raise"
          val invalid_arg : string -> 'a
          val failwith : string -> 'a
          exception Exit
          external ( = ) : 'a -> 'a -> bool = "%equal"
          external ( <> ) : 'a -> 'a -> bool = "%notequal"
          external ( < ) : 'a -> 'a -> bool = "%lessthan"
          external ( > ) : 'a -> 'a -> bool = "%greaterthan"
          external ( <= ) : 'a -> 'a -> bool = "%lessequal"
          external ( >= ) : 'a -> 'a -> bool = "%greaterequal"
          external compare : 'a -> 'a -> int = "%compare"
          val min : 'a -> 'a -> 'a
          val max : 'a -> 'a -> 'a
          external ( == ) : 'a -> 'a -> bool = "%eq"
          external ( != ) : 'a -> 'a -> bool = "%noteq"
          external not : bool -> bool = "%boolnot"
          external ( && ) : bool -> bool -> bool = "%sequand"
          external ( & ) : bool -> bool -> bool = "%sequand"
          external ( || ) : bool -> bool -> bool = "%sequor"
          external ( or ) : bool -> bool -> bool = "%sequor"
          external ( |> ) : 'a -> ('a -> 'b) -> 'b = "%revapply"
          external ( @@ ) : ('a -> 'b) -> 'a -> 'b = "%apply"
          external ( ~- ) : int -> int = "%negint"
          external ( ~+ ) : int -> int = "%identity"
          external succ : int -> int = "%succint"
          external pred : int -> int = "%predint"
          external ( + ) : int -> int -> int = "%addint"
          external ( - ) : int -> int -> int = "%subint"
          external ( * ) : int -> int -> int = "%mulint"
          external ( / ) : int -> int -> int = "%divint"
          external ( mod ) : int -> int -> int = "%modint"
          val abs : int -> int
          val max_int : int
          val min_int : int
          external ( land ) : int -> int -> int = "%andint"
          external ( lor ) : int -> int -> int = "%orint"
          external ( lxor ) : int -> int -> int = "%xorint"
          val lnot : int -> int
          external ( lsl ) : int -> int -> int = "%lslint"
          external ( lsr ) : int -> int -> int = "%lsrint"
          external ( asr ) : int -> int -> int = "%asrint"
          external ( ~-. ) : float -> float = "%negfloat"
          external ( ~+. ) : float -> float = "%identity"
          external ( +. ) : float -> float -> float = "%addfloat"
          external ( -. ) : float -> float -> float = "%subfloat"
          external ( *. ) : float -> float -> float = "%mulfloat"
          external ( /. ) : float -> float -> float = "%divfloat"
          external ( ** ) : float -> float -> float = "caml_power_float"
            "pow" "float"
          external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float"
          external exp : float -> float = "caml_exp_float" "exp" "float"
          external log : float -> float = "caml_log_float" "log" "float"
          external log10 : float -> float = "caml_log10_float" "log10"
            "float"
          external expm1 : float -> float = "caml_expm1_float" "caml_expm1"
            "float"
          external log1p : float -> float = "caml_log1p_float" "caml_log1p"
            "float"
          external cos : float -> float = "caml_cos_float" "cos" "float"
          external sin : float -> float = "caml_sin_float" "sin" "float"
          external tan : float -> float = "caml_tan_float" "tan" "float"
          external acos : float -> float = "caml_acos_float" "acos" "float"
          external asin : float -> float = "caml_asin_float" "asin" "float"
          external atan : float -> float = "caml_atan_float" "atan" "float"
          external atan2 : float -> float -> float = "caml_atan2_float"
            "atan2" "float"
          external hypot : float -> float -> float = "caml_hypot_float"
            "caml_hypot" "float"
          external cosh : float -> float = "caml_cosh_float" "cosh" "float"
          external sinh : float -> float = "caml_sinh_float" "sinh" "float"
          external tanh : float -> float = "caml_tanh_float" "tanh" "float"
          external ceil : float -> float = "caml_ceil_float" "ceil" "float"
          external floor : float -> float = "caml_floor_float" "floor"
            "float"
          external abs_float : float -> float = "%absfloat"
          external copysign : float -> float -> float = "caml_copysign_float"
            "caml_copysign" "float"
          external mod_float : float -> float -> float = "caml_fmod_float"
            "fmod" "float"
          external frexp : float -> float * int = "caml_frexp_float"
          external ldexp : float -> int -> float = "caml_ldexp_float"
          external modf : float -> float * float = "caml_modf_float"
          external float : int -> float = "%floatofint"
          external float_of_int : int -> float = "%floatofint"
          external truncate : float -> int = "%intoffloat"
          external int_of_float : float -> int = "%intoffloat"
          val infinity : float
          val neg_infinity : float
          val nan : float
          val max_float : float
          val min_float : float
          val epsilon_float : float
          type fpclass =
            fpclass =
              FP_normal
            | FP_subnormal
            | FP_zero
            | FP_infinite
            | FP_nan
          external classify_float : float -> fpclass = "caml_classify_float"
          val ( ^ ) : string -> string -> string
          external int_of_char : char -> int = "%identity"
          val char_of_int : int -> char
          external ignore : 'a -> unit = "%ignore"
          val string_of_bool : bool -> string
          val bool_of_string : string -> bool
          val string_of_int : int -> string
          external int_of_string : string -> int = "caml_int_of_string"
          val string_of_float : float -> string
          external float_of_string : string -> float = "caml_float_of_string"
          external fst : 'a * 'b -> 'a = "%field0"
          external snd : 'a * 'b -> 'b = "%field1"
          val ( @ ) : 'a list -> 'a list -> 'a list
          type in_channel = in_channel
          type out_channel = out_channel
          val stdin : in_channel
          val stdout : out_channel
          val stderr : out_channel
          val print_char : char -> unit
          val print_string : string -> unit
          val print_int : int -> unit
          val print_float : float -> unit
          val print_endline : string -> unit
          val print_newline : unit -> unit
          val prerr_char : char -> unit
          val prerr_string : string -> unit
          val prerr_int : int -> unit
          val prerr_float : float -> unit
          val prerr_endline : string -> unit
          val prerr_newline : unit -> unit
          val read_line : unit -> string
          val read_int : unit -> int
          val read_float : unit -> float
          type open_flag =
            open_flag =
              Open_rdonly
            | Open_wronly
            | Open_append
            | Open_creat
            | Open_trunc
            | Open_excl
            | Open_binary
            | Open_text
            | Open_nonblock
          val open_out : string -> out_channel
          val open_out_bin : string -> out_channel
          val open_out_gen : open_flag list -> int -> string -> out_channel
          val flush : out_channel -> unit
          val flush_all : unit -> unit
          val output_char : out_channel -> char -> unit
          val output_string : out_channel -> string -> unit
          val output : out_channel -> string -> int -> int -> unit
          val output_byte : out_channel -> int -> unit
          val output_binary_int : out_channel -> int -> unit
          val output_value : out_channel -> 'a -> unit
          val seek_out : out_channel -> int -> unit
          val pos_out : out_channel -> int
          val out_channel_length : out_channel -> int
          val close_out : out_channel -> unit
          val close_out_noerr : out_channel -> unit
          val set_binary_mode_out : out_channel -> bool -> unit
          val open_in : string -> in_channel
          val open_in_bin : string -> in_channel
          val open_in_gen : open_flag list -> int -> string -> in_channel
          val input_char : in_channel -> char
          val input_line : in_channel -> string
          val input : in_channel -> string -> int -> int -> int
          val really_input : in_channel -> string -> int -> int -> unit
          val input_byte : in_channel -> int
          val input_binary_int : in_channel -> int
          val input_value : in_channel -> 'a
          val seek_in : in_channel -> int -> unit
          val pos_in : in_channel -> int
          val in_channel_length : in_channel -> int
          val close_in : in_channel -> unit
          val close_in_noerr : in_channel -> unit
          val set_binary_mode_in : in_channel -> bool -> unit
          module LargeFile :
            sig
              val seek_out : out_channel -> int64 -> unit
              val pos_out : out_channel -> int64
              val out_channel_length : out_channel -> int64
              val seek_in : in_channel -> int64 -> unit
              val pos_in : in_channel -> int64
              val in_channel_length : in_channel -> int64
            end
          type 'a ref = 'a ref = { mutable contents : 'a; }
          external ref : 'a -> 'a ref = "%makemutable"
          external ( ! ) : 'a ref -> 'a = "%field0"
          external ( := ) : 'a ref -> 'a -> unit = "%setfield0"
          external incr : int ref -> unit = "%incr"
          external decr : int ref -> unit = "%decr"
          type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
          type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
          val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
          external format_of_string :
            ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
            ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity"
          val ( ^^ ) :
            ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
            ('f, 'b, 'c, 'e, 'g, 'h) format6 ->
            ('a, 'b, 'c, 'd, 'g, 'h) format6
          val exit : int -> 'a
          val at_exit : (unit -> unit) -> unit
          val valid_float_lexem : string -> string
          val unsafe_really_input :
            in_channel -> string -> int -> int -> unit
          val do_at_exit : unit -> unit
        end
      module Printexc :
        sig
          val to_string : exn -> string
          val print : ('a -> 'b) -> 'a -> 'b
          val catch : ('a -> 'b) -> 'a -> 'b
          val print_backtrace : out_channel -> unit
          val get_backtrace : unit -> string
          val record_backtrace : bool -> unit
          val backtrace_status : unit -> bool
          val register_printer : (exn -> string option) -> unit
          type raw_backtrace = Printexc.raw_backtrace
          val get_raw_backtrace : unit -> raw_backtrace
          val print_raw_backtrace : out_channel -> raw_backtrace -> unit
          val raw_backtrace_to_string : raw_backtrace -> string
          val get_callstack : int -> raw_backtrace
        end
      module Printf :
        sig
          val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a
          val printf : ('a, out_channel, unit) format -> 'a
          val eprintf : ('a, out_channel, unit) format -> 'a
          val sprintf : ('a, unit, string) format -> 'a
          val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a
          val ifprintf : 'a -> ('b, 'a, unit) format -> 'b
          val kfprintf :
            (out_channel -> 'a) ->
            out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b
          val ikfprintf :
            (out_channel -> 'a) ->
            out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b
          val ksprintf :
            (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
          val kbprintf :
            (Buffer.t -> 'a) ->
            Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b
          val kprintf :
            (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
          module CamlinternalPr :
            sig
              module Sformat :
                sig
                  type index = Printf.CamlinternalPr.Sformat.index
                  val index_of_int : int -> index
                  external int_of_index : index -> int = "%identity"
                  external unsafe_index_of_int : int -> index = "%identity"
                  val succ_index : index -> index
                  val add_int_index : int -> index -> index
                  val sub :
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
                    index -> int -> string
                  val to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
                  external length : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int
                    = "%string_length"
                  external get :
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char
                    = "%string_safe_get"
                  external unsafe_to_string :
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string = "%identity"
                  external unsafe_get :
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char
                    = "%string_unsafe_get"
                end
              module Tformat :
                sig
                  type ac =
                    Printf.CamlinternalPr.Tformat.ac = {
                    mutable ac_rglr : int;
                    mutable ac_skip : int;
                    mutable ac_rdrs : int;
                  }
                  val ac_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ac
                  val count_printing_arguments_of_format :
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int
                  val sub_format :
                    (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int) ->
                    (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char -> int) ->
                    char -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> int
                  val summarize_format_type :
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
                  val scan_format :
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
                    'g array ->
                    Sformat.index ->
                    int ->
                    (Sformat.index -> string -> int -> 'h) ->
                    (Sformat.index -> 'i -> 'j -> int -> 'h) ->
                    (Sformat.index -> 'k -> int -> 'h) ->
                    (Sformat.index -> int -> 'h) ->
                    (Sformat.index ->
                     ('l, 'm, 'n, 'o, 'p, 'q) format6 -> int -> 'h) ->
                    'h
                  val kapr :
                    (('a, 'b, 'c, 'd, 'e, 'f) format6 -> Obj.t array -> 'g) ->
                    ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g
                end
            end
        end
      module Queue :
        sig
          type 'a t = 'a Queue.t
          exception Empty
          val create : unit -> 'a t
          val add : 'a -> 'a t -> unit
          val push : 'a -> 'a t -> unit
          val take : 'a t -> 'a
          val pop : 'a t -> 'a
          val peek : 'a t -> 'a
          val top : 'a t -> 'a
          val clear : 'a t -> unit
          val copy : 'a t -> 'a t
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val iter : ('a -> unit) -> 'a t -> unit
          val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
          val transfer : 'a t -> 'a t -> unit
        end
      module Random :
        sig
          val init : int -> unit
          val full_init : int array -> unit
          val self_init : unit -> unit
          val bits : unit -> int
          val int : int -> int
          val int32 : Int32.t -> Int32.t
          val nativeint : Nativeint.t -> Nativeint.t
          val int64 : Int64.t -> Int64.t
          val float : float -> float
          val bool : unit -> bool
          module State :
            sig
              type t = Random.State.t
              val make : int array -> t
              val make_self_init : unit -> t
              val copy : t -> t
              val bits : t -> int
              val int : t -> int -> int
              val int32 : t -> Int32.t -> Int32.t
              val nativeint : t -> Nativeint.t -> Nativeint.t
              val int64 : t -> Int64.t -> Int64.t
              val float : t -> float -> float
              val bool : t -> bool
            end
          val get_state : unit -> State.t
          val set_state : State.t -> unit
        end
      module Scanf :
        sig
          module Scanning :
            sig
              type in_channel = Scanf.Scanning.in_channel
              type scanbuf = in_channel
              val stdin : in_channel
              type file_name = string
              val open_in : file_name -> in_channel
              val open_in_bin : file_name -> in_channel
              val close_in : in_channel -> unit
              val from_file : file_name -> in_channel
              val from_file_bin : string -> in_channel
              val from_string : string -> in_channel
              val from_function : (unit -> char) -> in_channel
              val from_channel : in_channel -> in_channel
              val end_of_input : in_channel -> bool
              val beginning_of_input : in_channel -> bool
              val name_of_input : in_channel -> string
              val stdib : in_channel
            end
          type ('a, 'b, 'c, 'd) scanner =
              ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c
          exception Scan_failure of string
          val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner
          val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner
          val sscanf : string -> ('a, 'b, 'c, 'd) scanner
          val scanf : ('a, 'b, 'c, 'd) scanner
          val kscanf :
            Scanning.in_channel ->
            (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner
          val bscanf_format :
            Scanning.in_channel ->
            ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
            (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g
          val sscanf_format :
            string ->
            ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
            (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g
          val format_from_string :
            string ->
            ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
            ('a, 'b, 'c, 'd, 'e, 'f) format6
          val unescaped : string -> string
        end
      module Set :
        sig
          module type OrderedType =
            sig type t val compare : t -> t -> int end
          module type S =
            sig
              type elt
              type t
              val empty : t
              val is_empty : t -> bool
              val mem : elt -> t -> bool
              val add : elt -> t -> t
              val singleton : elt -> t
              val remove : elt -> t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val compare : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
              val for_all : (elt -> bool) -> t -> bool
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val partition : (elt -> bool) -> t -> t * t
              val cardinal : t -> int
              val elements : t -> elt list
              val min_elt : t -> elt
              val max_elt : t -> elt
              val choose : t -> elt
              val split : elt -> t -> t * bool * t
              val find : elt -> t -> elt
            end
          module Make :
            functor (Ord : OrderedType) ->
              sig
                type elt = Ord.t
                type t = Set.Make(Ord).t
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
              end
        end
      module Sort :
        sig
          val list : ('a -> 'a -> bool) -> 'a list -> 'a list
          val array : ('a -> 'a -> bool) -> 'a array -> unit
          val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list
        end
      module Stack :
        sig
          type 'a t = 'a Stack.t
          exception Empty
          val create : unit -> 'a t
          val push : 'a -> 'a t -> unit
          val pop : 'a t -> 'a
          val top : 'a t -> 'a
          val clear : 'a t -> unit
          val copy : 'a t -> 'a t
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val iter : ('a -> unit) -> 'a t -> unit
        end
      module StdLabels :
        sig
          module Array :
            sig
              external length : 'a array -> int = "%array_length"
              external get : 'a array -> int -> 'a = "%array_safe_get"
              external set : 'a array -> int -> 'a -> unit
                = "%array_safe_set"
              external make : int -> 'a -> 'a array = "caml_make_vect"
              external create : int -> 'a -> 'a array = "caml_make_vect"
              val init : int -> f:(int -> 'a) -> 'a array
              val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
              val create_matrix :
                dimx:int -> dimy:int -> 'a -> 'a array array
              val append : 'a array -> 'a array -> 'a array
              val concat : 'a array list -> 'a array
              val sub : 'a array -> pos:int -> len:int -> 'a array
              val copy : 'a array -> 'a array
              val fill : 'a array -> pos:int -> len:int -> 'a -> unit
              val blit :
                src:'a array ->
                src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit
              val to_list : 'a array -> 'a list
              val of_list : 'a list -> 'a array
              val iter : f:('a -> unit) -> 'a array -> unit
              val map : f:('a -> 'b) -> 'a array -> 'b array
              val iteri : f:(int -> 'a -> unit) -> 'a array -> unit
              val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array
              val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a
              val fold_right :
                f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b
              val sort : cmp:('a -> 'a -> int) -> 'a array -> unit
              val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
              val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
              external unsafe_get : 'a array -> int -> 'a
                = "%array_unsafe_get"
              external unsafe_set : 'a array -> int -> 'a -> unit
                = "%array_unsafe_set"
            end
          module List :
            sig
              val length : 'a list -> int
              val hd : 'a list -> 'a
              val tl : 'a list -> 'a list
              val nth : 'a list -> int -> 'a
              val rev : 'a list -> 'a list
              val append : 'a list -> 'a list -> 'a list
              val rev_append : 'a list -> 'a list -> 'a list
              val concat : 'a list list -> 'a list
              val flatten : 'a list list -> 'a list
              val iter : f:('a -> unit) -> 'a list -> unit
              val map : f:('a -> 'b) -> 'a list -> 'b list
              val rev_map : f:('a -> 'b) -> 'a list -> 'b list
              val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a
              val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b
              val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
              val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
              val rev_map2 :
                f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
              val fold_left2 :
                f:('a -> 'b -> 'c -> 'a) ->
                init:'a -> 'b list -> 'c list -> 'a
              val fold_right2 :
                f:('a -> 'b -> 'c -> 'c) ->
                'a list -> 'b list -> init:'c -> 'c
              val for_all : f:('a -> bool) -> 'a list -> bool
              val exists : f:('a -> bool) -> 'a list -> bool
              val for_all2 :
                f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
              val exists2 :
                f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
              val mem : 'a -> set:'a list -> bool
              val memq : 'a -> set:'a list -> bool
              val find : f:('a -> bool) -> 'a list -> 'a
              val filter : f:('a -> bool) -> 'a list -> 'a list
              val find_all : f:('a -> bool) -> 'a list -> 'a list
              val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
              val assoc : 'a -> ('a * 'b) list -> 'b
              val assq : 'a -> ('a * 'b) list -> 'b
              val mem_assoc : 'a -> map:('a * 'b) list -> bool
              val mem_assq : 'a -> map:('a * 'b) list -> bool
              val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
              val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
              val split : ('a * 'b) list -> 'a list * 'b list
              val combine : 'a list -> 'b list -> ('a * 'b) list
              val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
              val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
              val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
              val merge :
                cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
            end
          module String :
            sig
              external length : string -> int = "%string_length"
              external get : string -> int -> char = "%string_safe_get"
              external set : string -> int -> char -> unit
                = "%string_safe_set"
              external create : int -> string = "caml_create_string"
              val make : int -> char -> string
              val copy : string -> string
              val sub : string -> pos:int -> len:int -> string
              val fill : string -> pos:int -> len:int -> char -> unit
              val blit :
                src:string ->
                src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit
              val concat : sep:string -> string list -> string
              val iter : f:(char -> unit) -> string -> unit
              val iteri : f:(int -> char -> unit) -> string -> unit
              val map : f:(char -> char) -> string -> string
              val trim : string -> string
              val escaped : string -> string
              val index : string -> char -> int
              val rindex : string -> char -> int
              val index_from : string -> int -> char -> int
              val rindex_from : string -> int -> char -> int
              val contains : string -> char -> bool
              val contains_from : string -> int -> char -> bool
              val rcontains_from : string -> int -> char -> bool
              val uppercase : string -> string
              val lowercase : string -> string
              val capitalize : string -> string
              val uncapitalize : string -> string
              type t = string
              val compare : t -> t -> int
              external unsafe_get : string -> int -> char
                = "%string_unsafe_get"
              external unsafe_set : string -> int -> char -> unit
                = "%string_unsafe_set"
              external unsafe_blit :
                src:string ->
                src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit
                = "caml_blit_string" "noalloc"
              external unsafe_fill :
                string -> pos:int -> len:int -> char -> unit
                = "caml_fill_string" "noalloc"
            end
        end
      module Stream :
        sig
          type 'a t = 'a Stream.t
          exception Failure
          exception Error of string
          val from : (int -> 'a option) -> 'a t
          val of_list : 'a list -> 'a t
          val of_string : string -> char t
          val of_channel : in_channel -> char t
          val iter : ('a -> unit) -> 'a t -> unit
          val next : 'a t -> 'a
          val empty : 'a t -> unit
          val peek : 'a t -> 'a option
          val junk : 'a t -> unit
          val count : 'a t -> int
          val npeek : int -> 'a t -> 'a list
          val iapp : 'a t -> 'a t -> 'a t
          val icons : 'a -> 'a t -> 'a t
          val ising : 'a -> 'a t
          val lapp : (unit -> 'a t) -> 'a t -> 'a t
          val lcons : (unit -> 'a) -> 'a t -> 'a t
          val lsing : (unit -> 'a) -> 'a t
          val sempty : 'a t
          val slazy : (unit -> 'a t) -> 'a t
          val dump : ('a -> unit) -> 'a t -> unit
        end
      module String :
        sig
          external length : string -> int = "%string_length"
          external get : string -> int -> char = "%string_safe_get"
          external set : string -> int -> char -> unit = "%string_safe_set"
          external create : int -> string = "caml_create_string"
          val make : int -> char -> string
          val copy : string -> string
          val sub : string -> int -> int -> string
          val fill : string -> int -> int -> char -> unit
          val blit : string -> int -> string -> int -> int -> unit
          val concat : string -> string list -> string
          val iter : (char -> unit) -> string -> unit
          val iteri : (int -> char -> unit) -> string -> unit
          val map : (char -> char) -> string -> string
          val trim : string -> string
          val escaped : string -> string
          val index : string -> char -> int
          val rindex : string -> char -> int
          val index_from : string -> int -> char -> int
          val rindex_from : string -> int -> char -> int
          val contains : string -> char -> bool
          val contains_from : string -> int -> char -> bool
          val rcontains_from : string -> int -> char -> bool
          val uppercase : string -> string
          val lowercase : string -> string
          val capitalize : string -> string
          val uncapitalize : string -> string
          type t = string
          val compare : t -> t -> int
          external unsafe_get : string -> int -> char = "%string_unsafe_get"
          external unsafe_set : string -> int -> char -> unit
            = "%string_unsafe_set"
          external unsafe_blit :
            string -> int -> string -> int -> int -> unit
            = "caml_blit_string" "noalloc"
          external unsafe_fill : string -> int -> int -> char -> unit
            = "caml_fill_string" "noalloc"
        end
      module StringLabels :
        sig
          external length : string -> int = "%string_length"
          external get : string -> int -> char = "%string_safe_get"
          external set : string -> int -> char -> unit = "%string_safe_set"
          external create : int -> string = "caml_create_string"
          val make : int -> char -> string
          val copy : string -> string
          val sub : string -> pos:int -> len:int -> string
          val fill : string -> pos:int -> len:int -> char -> unit
          val blit :
            src:string ->
            src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit
          val concat : sep:string -> string list -> string
          val iter : f:(char -> unit) -> string -> unit
          val iteri : f:(int -> char -> unit) -> string -> unit
          val map : f:(char -> char) -> string -> string
          val trim : string -> string
          val escaped : string -> string
          val index : string -> char -> int
          val rindex : string -> char -> int
          val index_from : string -> int -> char -> int
          val rindex_from : string -> int -> char -> int
          val contains : string -> char -> bool
          val contains_from : string -> int -> char -> bool
          val rcontains_from : string -> int -> char -> bool
          val uppercase : string -> string
          val lowercase : string -> string
          val capitalize : string -> string
          val uncapitalize : string -> string
          type t = string
          val compare : t -> t -> int
          external unsafe_get : string -> int -> char = "%string_unsafe_get"
          external unsafe_set : string -> int -> char -> unit
            = "%string_unsafe_set"
          external unsafe_blit :
            src:string ->
            src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit
            = "caml_blit_string" "noalloc"
          external unsafe_fill : string -> pos:int -> len:int -> char -> unit
            = "caml_fill_string" "noalloc"
        end
      module Sys :
        sig
          val argv : string array
          val executable_name : string
          external file_exists : string -> bool = "caml_sys_file_exists"
          external is_directory : string -> bool = "caml_sys_is_directory"
          external remove : string -> unit = "caml_sys_remove"
          external rename : string -> string -> unit = "caml_sys_rename"
          external getenv : string -> string = "caml_sys_getenv"
          external command : string -> int = "caml_sys_system_command"
          external time : unit -> float = "caml_sys_time"
          external chdir : string -> unit = "caml_sys_chdir"
          external getcwd : unit -> string = "caml_sys_getcwd"
          external readdir : string -> string array
            = "caml_sys_read_directory"
          val interactive : bool ref
          val os_type : string
          val unix : bool
          val win32 : bool
          val cygwin : bool
          val word_size : int
          val big_endian : bool
          val max_string_length : int
          val max_array_length : int
          type signal_behavior =
            Sys.signal_behavior =
              Signal_default
            | Signal_ignore
            | Signal_handle of (int -> unit)
          external signal : int -> signal_behavior -> signal_behavior
            = "caml_install_signal_handler"
          val set_signal : int -> signal_behavior -> unit
          val sigabrt : int
          val sigalrm : int
          val sigfpe : int
          val sighup : int
          val sigill : int
          val sigint : int
          val sigkill : int
          val sigpipe : int
          val sigquit : int
          val sigsegv : int
          val sigterm : int
          val sigusr1 : int
          val sigusr2 : int
          val sigchld : int
          val sigcont : int
          val sigstop : int
          val sigtstp : int
          val sigttin : int
          val sigttou : int
          val sigvtalrm : int
          val sigprof : int
          exception Break
          val catch_break : bool -> unit
          val ocaml_version : string
        end
      module Weak :
        sig
          type 'a t = 'a Weak.t
          val create : int -> 'a t
          val length : 'a t -> int
          val set : 'a t -> int -> 'a option -> unit
          val get : 'a t -> int -> 'a option
          val get_copy : 'a t -> int -> 'a option
          val check : 'a t -> int -> bool
          val fill : 'a t -> int -> int -> 'a option -> unit
          val blit : 'a t -> int -> 'a t -> int -> int -> unit
          module type S =
            sig
              type data
              type t
              val create : int -> t
              val clear : t -> unit
              val merge : t -> data -> data
              val add : t -> data -> unit
              val remove : t -> data -> unit
              val find : t -> data -> data
              val find_all : t -> data -> data list
              val mem : t -> data -> bool
              val iter : (data -> unit) -> t -> unit
              val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a
              val count : t -> int
              val stats : t -> int * int * int * int * int * int
            end
          module Make :
            functor (H : Hashtbl.HashedType) ->
              sig
                type data = H.t
                type t = Weak.Make(H).t
                val create : int -> t
                val clear : t -> unit
                val merge : t -> data -> data
                val add : t -> data -> unit
                val remove : t -> data -> unit
                val find : t -> data -> data
                val find_all : t -> data -> data list
                val mem : t -> data -> bool
                val iter : (data -> unit) -> t -> unit
                val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a
                val count : t -> int
                val stats : t -> int * int * int * int * int * int
              end
        end
      external raise : exn -> 'a = "%raise"
      val invalid_arg : string -> 'a
      val failwith : string -> 'a
      exception Exit
      external ( = ) : 'a -> 'a -> bool = "%equal"
      external ( <> ) : 'a -> 'a -> bool = "%notequal"
      external ( < ) : 'a -> 'a -> bool = "%lessthan"
      external ( > ) : 'a -> 'a -> bool = "%greaterthan"
      external ( <= ) : 'a -> 'a -> bool = "%lessequal"
      external ( >= ) : 'a -> 'a -> bool = "%greaterequal"
      external compare : 'a -> 'a -> int = "%compare"
      val min : 'a -> 'a -> 'a
      val max : 'a -> 'a -> 'a
      external ( == ) : 'a -> 'a -> bool = "%eq"
      external ( != ) : 'a -> 'a -> bool = "%noteq"
      external not : bool -> bool = "%boolnot"
      external ( && ) : bool -> bool -> bool = "%sequand"
      external ( & ) : bool -> bool -> bool = "%sequand"
      external ( || ) : bool -> bool -> bool = "%sequor"
      external ( or ) : bool -> bool -> bool = "%sequor"
      external ( |> ) : 'a -> ('a -> 'b) -> 'b = "%revapply"
      external ( @@ ) : ('a -> 'b) -> 'a -> 'b = "%apply"
      external ( ~- ) : int -> int = "%negint"
      external ( ~+ ) : int -> int = "%identity"
      external succ : int -> int = "%succint"
      external pred : int -> int = "%predint"
      external ( + ) : int -> int -> int = "%addint"
      external ( - ) : int -> int -> int = "%subint"
      external ( * ) : int -> int -> int = "%mulint"
      external ( / ) : int -> int -> int = "%divint"
      external ( mod ) : int -> int -> int = "%modint"
      val abs : int -> int
      val max_int : int
      val min_int : int
      external ( land ) : int -> int -> int = "%andint"
      external ( lor ) : int -> int -> int = "%orint"
      external ( lxor ) : int -> int -> int = "%xorint"
      val lnot : int -> int
      external ( lsl ) : int -> int -> int = "%lslint"
      external ( lsr ) : int -> int -> int = "%lsrint"
      external ( asr ) : int -> int -> int = "%asrint"
      external ( ~-. ) : float -> float = "%negfloat"
      external ( ~+. ) : float -> float = "%identity"
      external ( +. ) : float -> float -> float = "%addfloat"
      external ( -. ) : float -> float -> float = "%subfloat"
      external ( *. ) : float -> float -> float = "%mulfloat"
      external ( /. ) : float -> float -> float = "%divfloat"
      external ( ** ) : float -> float -> float = "caml_power_float" "pow"
        "float"
      external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float"
      external exp : float -> float = "caml_exp_float" "exp" "float"
      external log : float -> float = "caml_log_float" "log" "float"
      external log10 : float -> float = "caml_log10_float" "log10" "float"
      external expm1 : float -> float = "caml_expm1_float" "caml_expm1"
        "float"
      external log1p : float -> float = "caml_log1p_float" "caml_log1p"
        "float"
      external cos : float -> float = "caml_cos_float" "cos" "float"
      external sin : float -> float = "caml_sin_float" "sin" "float"
      external tan : float -> float = "caml_tan_float" "tan" "float"
      external acos : float -> float = "caml_acos_float" "acos" "float"
      external asin : float -> float = "caml_asin_float" "asin" "float"
      external atan : float -> float = "caml_atan_float" "atan" "float"
      external atan2 : float -> float -> float = "caml_atan2_float" "atan2"
        "float"
      external hypot : float -> float -> float = "caml_hypot_float"
        "caml_hypot" "float"
      external cosh : float -> float = "caml_cosh_float" "cosh" "float"
      external sinh : float -> float = "caml_sinh_float" "sinh" "float"
      external tanh : float -> float = "caml_tanh_float" "tanh" "float"
      external ceil : float -> float = "caml_ceil_float" "ceil" "float"
      external floor : float -> float = "caml_floor_float" "floor" "float"
      external abs_float : float -> float = "%absfloat"
      external copysign : float -> float -> float = "caml_copysign_float"
        "caml_copysign" "float"
      external mod_float : float -> float -> float = "caml_fmod_float" "fmod"
        "float"
      external frexp : float -> float * int = "caml_frexp_float"
      external ldexp : float -> int -> float = "caml_ldexp_float"
      external modf : float -> float * float = "caml_modf_float"
      external float : int -> float = "%floatofint"
      external float_of_int : int -> float = "%floatofint"
      external truncate : float -> int = "%intoffloat"
      external int_of_float : float -> int = "%intoffloat"
      val infinity : float
      val neg_infinity : float
      val nan : float
      val max_float : float
      val min_float : float
      val epsilon_float : float
      type fpclass =
        fpclass =
          FP_normal
        | FP_subnormal
        | FP_zero
        | FP_infinite
        | FP_nan
      external classify_float : float -> fpclass = "caml_classify_float"
      val ( ^ ) : string -> string -> string
      external int_of_char : char -> int = "%identity"
      val char_of_int : int -> char
      external ignore : 'a -> unit = "%ignore"
      val string_of_bool : bool -> string
      val bool_of_string : string -> bool
      val string_of_int : int -> string
      external int_of_string : string -> int = "caml_int_of_string"
      val string_of_float : float -> string
      external float_of_string : string -> float = "caml_float_of_string"
      external fst : 'a * 'b -> 'a = "%field0"
      external snd : 'a * 'b -> 'b = "%field1"
      val ( @ ) : 'a list -> 'a list -> 'a list
      type in_channel = in_channel
      type out_channel = out_channel
      val stdin : in_channel
      val stdout : out_channel
      val stderr : out_channel
      val print_char : char -> unit
      val print_string : string -> unit
      val print_int : int -> unit
      val print_float : float -> unit
      val print_endline : string -> unit
      val print_newline : unit -> unit
      val prerr_char : char -> unit
      val prerr_string : string -> unit
      val prerr_int : int -> unit
      val prerr_float : float -> unit
      val prerr_endline : string -> unit
      val prerr_newline : unit -> unit
      val read_line : unit -> string
      val read_int : unit -> int
      val read_float : unit -> float
      type open_flag =
        open_flag =
          Open_rdonly
        | Open_wronly
        | Open_append
        | Open_creat
        | Open_trunc
        | Open_excl
        | Open_binary
        | Open_text
        | Open_nonblock
      val open_out : string -> out_channel
      val open_out_bin : string -> out_channel
      val open_out_gen : open_flag list -> int -> string -> out_channel
      val flush : out_channel -> unit
      val flush_all : unit -> unit
      val output_char : out_channel -> char -> unit
      val output_string : out_channel -> string -> unit
      val output : out_channel -> string -> int -> int -> unit
      val output_byte : out_channel -> int -> unit
      val output_binary_int : out_channel -> int -> unit
      val output_value : out_channel -> 'a -> unit
      val seek_out : out_channel -> int -> unit
      val pos_out : out_channel -> int
      val out_channel_length : out_channel -> int
      val close_out : out_channel -> unit
      val close_out_noerr : out_channel -> unit
      val set_binary_mode_out : out_channel -> bool -> unit
      val open_in : string -> in_channel
      val open_in_bin : string -> in_channel
      val open_in_gen : open_flag list -> int -> string -> in_channel
      val input_char : in_channel -> char
      val input_line : in_channel -> string
      val input : in_channel -> string -> int -> int -> int
      val really_input : in_channel -> string -> int -> int -> unit
      val input_byte : in_channel -> int
      val input_binary_int : in_channel -> int
      val input_value : in_channel -> 'a
      val seek_in : in_channel -> int -> unit
      val pos_in : in_channel -> int
      val in_channel_length : in_channel -> int
      val close_in : in_channel -> unit
      val close_in_noerr : in_channel -> unit
      val set_binary_mode_in : in_channel -> bool -> unit
      module LargeFile :
        sig
          val seek_out : out_channel -> int64 -> unit
          val pos_out : out_channel -> int64
          val out_channel_length : out_channel -> int64
          val seek_in : in_channel -> int64 -> unit
          val pos_in : in_channel -> int64
          val in_channel_length : in_channel -> int64
        end
      type 'a ref = 'a ref = { mutable contents : 'a; }
      external ref : 'a -> 'a ref = "%makemutable"
      external ( ! ) : 'a ref -> 'a = "%field0"
      external ( := ) : 'a ref -> 'a -> unit = "%setfield0"
      external incr : int ref -> unit = "%incr"
      external decr : int ref -> unit = "%decr"
      type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
      type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
      val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
      external format_of_string :
        ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
        = "%identity"
      val ( ^^ ) :
        ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
        ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
      val exit : int -> 'a
      val at_exit : (unit -> unit) -> unit
      val valid_float_lexem : string -> string
      val unsafe_really_input : in_channel -> string -> int -> int -> unit
      val do_at_exit : unit -> unit
      module Condition :
        sig
          type t = Condition.t
          val create : unit -> t
          val wait : t -> Mutex.t -> unit
          val signal : t -> unit
          val broadcast : t -> unit
        end
      module Mutex :
        sig
          type t = Mutex.t
          val create : unit -> t
          val lock : t -> unit
          val try_lock : t -> bool
          val unlock : t -> unit
        end
      module Thread :
        sig
          type t = Thread.t
          val create : ('a -> 'b) -> 'a -> t
          val self : unit -> t
          val id : t -> int
          val exit : unit -> unit
          val kill : t -> unit
          val delay : float -> unit
          val join : t -> unit
          val wait_read : Unix.file_descr -> unit
          val wait_write : Unix.file_descr -> unit
          val wait_timed_read : Unix.file_descr -> float -> bool
          val wait_timed_write : Unix.file_descr -> float -> bool
          val select :
            Unix.file_descr list ->
            Unix.file_descr list ->
            Unix.file_descr list ->
            float ->
            Unix.file_descr list * Unix.file_descr list *
            Unix.file_descr list
          val wait_pid : int -> int * Unix.process_status
          val yield : unit -> unit
          val sigmask : Unix.sigprocmask_command -> int list -> int list
          val wait_signal : int list -> int
        end
      module Unix :
        sig
          type error =
            Unix.error =
              E2BIG
            | EACCES
            | EAGAIN
            | EBADF
            | EBUSY
            | ECHILD
            | EDEADLK
            | EDOM
            | EEXIST
            | EFAULT
            | EFBIG
            | EINTR
            | EINVAL
            | EIO
            | EISDIR
            | EMFILE
            | EMLINK
            | ENAMETOOLONG
            | ENFILE
            | ENODEV
            | ENOENT
            | ENOEXEC
            | ENOLCK
            | ENOMEM
            | ENOSPC
            | ENOSYS
            | ENOTDIR
            | ENOTEMPTY
            | ENOTTY
            | ENXIO
            | EPERM
            | EPIPE
            | ERANGE
            | EROFS
            | ESPIPE
            | ESRCH
            | EXDEV
            | EWOULDBLOCK
            | EINPROGRESS
            | EALREADY
            | ENOTSOCK
            | EDESTADDRREQ
            | EMSGSIZE
            | EPROTOTYPE
            | ENOPROTOOPT
            | EPROTONOSUPPORT
            | ESOCKTNOSUPPORT
            | EOPNOTSUPP
            | EPFNOSUPPORT
            | EAFNOSUPPORT
            | EADDRINUSE
            | EADDRNOTAVAIL
            | ENETDOWN
            | ENETUNREACH
            | ENETRESET
            | ECONNABORTED
            | ECONNRESET
            | ENOBUFS
            | EISCONN
            | ENOTCONN
            | ESHUTDOWN
            | ETOOMANYREFS
            | ETIMEDOUT
            | ECONNREFUSED
            | EHOSTDOWN
            | EHOSTUNREACH
            | ELOOP
            | EOVERFLOW
            | EUNKNOWNERR of int
          exception Unix_error of error * string * string
          val error_message : error -> string
          val handle_unix_error : ('a -> 'b) -> 'a -> 'b
          val environment : unit -> string array
          val getenv : string -> string
          val putenv : string -> string -> unit
          type process_status =
            Unix.process_status =
              WEXITED of int
            | WSIGNALED of int
            | WSTOPPED of int
          type wait_flag = Unix.wait_flag = WNOHANG | WUNTRACED
          val execv : string -> string array -> 'a
          val execve : string -> string array -> string array -> 'a
          val execvp : string -> string array -> 'a
          val execvpe : string -> string array -> string array -> 'a
          val fork : unit -> int
          val wait : unit -> int * process_status
          val waitpid : wait_flag list -> int -> int * process_status
          val system : string -> process_status
          val getpid : unit -> int
          val getppid : unit -> int
          val nice : int -> int
          type file_descr = Unix.file_descr
          val stdin : file_descr
          val stdout : file_descr
          val stderr : file_descr
          type open_flag =
            Unix.open_flag =
              O_RDONLY
            | O_WRONLY
            | O_RDWR
            | O_NONBLOCK
            | O_APPEND
            | O_CREAT
            | O_TRUNC
            | O_EXCL
            | O_NOCTTY
            | O_DSYNC
            | O_SYNC
            | O_RSYNC
            | O_SHARE_DELETE
            | O_CLOEXEC
          type file_perm = int
          val openfile : string -> open_flag list -> file_perm -> file_descr
          val close : file_descr -> unit
          val read : file_descr -> string -> int -> int -> int
          val write : file_descr -> string -> int -> int -> int
          val single_write : file_descr -> string -> int -> int -> int
          val in_channel_of_descr : file_descr -> in_channel
          val out_channel_of_descr : file_descr -> out_channel
          val descr_of_in_channel : in_channel -> file_descr
          val descr_of_out_channel : out_channel -> file_descr
          type seek_command =
            Unix.seek_command =
              SEEK_SET
            | SEEK_CUR
            | SEEK_END
          val lseek : file_descr -> int -> seek_command -> int
          val truncate : string -> int -> unit
          val ftruncate : file_descr -> int -> unit
          type file_kind =
            Unix.file_kind =
              S_REG
            | S_DIR
            | S_CHR
            | S_BLK
            | S_LNK
            | S_FIFO
            | S_SOCK
          type stats =
            Unix.stats = {
            st_dev : int;
            st_ino : int;
            st_kind : file_kind;
            st_perm : file_perm;
            st_nlink : int;
            st_uid : int;
            st_gid : int;
            st_rdev : int;
            st_size : int;
            st_atime : float;
            st_mtime : float;
            st_ctime : float;
          }
          val stat : string -> stats
          val lstat : string -> stats
          val fstat : file_descr -> stats
          val isatty : file_descr -> bool
          module LargeFile :
            sig
              val lseek : file_descr -> int64 -> seek_command -> int64
              val truncate : string -> int64 -> unit
              val ftruncate : file_descr -> int64 -> unit
              type stats =
                Unix.LargeFile.stats = {
                st_dev : int;
                st_ino : int;
                st_kind : file_kind;
                st_perm : file_perm;
                st_nlink : int;
                st_uid : int;
                st_gid : int;
                st_rdev : int;
                st_size : int64;
                st_atime : float;
                st_mtime : float;
                st_ctime : float;
              }
              val stat : string -> stats
              val lstat : string -> stats
              val fstat : file_descr -> stats
            end
          val unlink : string -> unit
          val rename : string -> string -> unit
          val link : string -> string -> unit
          type access_permission =
            Unix.access_permission =
              R_OK
            | W_OK
            | X_OK
            | F_OK
          val chmod : string -> file_perm -> unit
          val fchmod : file_descr -> file_perm -> unit
          val chown : string -> int -> int -> unit
          val fchown : file_descr -> int -> int -> unit
          val umask : int -> int
          val access : string -> access_permission list -> unit
          val dup : file_descr -> file_descr
          val dup2 : file_descr -> file_descr -> unit
          val set_nonblock : file_descr -> unit
          val clear_nonblock : file_descr -> unit
          val set_close_on_exec : file_descr -> unit
          val clear_close_on_exec : file_descr -> unit
          val mkdir : string -> file_perm -> unit
          val rmdir : string -> unit
          val chdir : string -> unit
          val getcwd : unit -> string
          val chroot : string -> unit
          type dir_handle = Unix.dir_handle
          val opendir : string -> dir_handle
          val readdir : dir_handle -> string
          val rewinddir : dir_handle -> unit
          val closedir : dir_handle -> unit
          val pipe : unit -> file_descr * file_descr
          val mkfifo : string -> file_perm -> unit
          val create_process :
            string ->
            string array -> file_descr -> file_descr -> file_descr -> int
          val create_process_env :
            string ->
            string array ->
            string array -> file_descr -> file_descr -> file_descr -> int
          val open_process_in : string -> in_channel
          val open_process_out : string -> out_channel
          val open_process : string -> in_channel * out_channel
          val open_process_full :
            string -> string array -> in_channel * out_channel * in_channel
          val close_process_in : in_channel -> process_status
          val close_process_out : out_channel -> process_status
          val close_process : in_channel * out_channel -> process_status
          val close_process_full :
            in_channel * out_channel * in_channel -> process_status
          val symlink : string -> string -> unit
          val readlink : string -> string
          val select :
            file_descr list ->
            file_descr list ->
            file_descr list ->
            float -> file_descr list * file_descr list * file_descr list
          type lock_command =
            Unix.lock_command =
              F_ULOCK
            | F_LOCK
            | F_TLOCK
            | F_TEST
            | F_RLOCK
            | F_TRLOCK
          val lockf : file_descr -> lock_command -> int -> unit
          val kill : int -> int -> unit
          type sigprocmask_command =
            Unix.sigprocmask_command =
              SIG_SETMASK
            | SIG_BLOCK
            | SIG_UNBLOCK
          val sigprocmask : sigprocmask_command -> int list -> int list
          val sigpending : unit -> int list
          val sigsuspend : int list -> unit
          val pause : unit -> unit
          type process_times =
            Unix.process_times = {
            tms_utime : float;
            tms_stime : float;
            tms_cutime : float;
            tms_cstime : float;
          }
          type tm =
            Unix.tm = {
            tm_sec : int;
            tm_min : int;
            tm_hour : int;
            tm_mday : int;
            tm_mon : int;
            tm_year : int;
            tm_wday : int;
            tm_yday : int;
            tm_isdst : bool;
          }
          val time : unit -> float
          val gettimeofday : unit -> float
          val gmtime : float -> tm
          val localtime : float -> tm
          val mktime : tm -> float * tm
          val alarm : int -> int
          val sleep : int -> unit
          val times : unit -> process_times
          val utimes : string -> float -> float -> unit
          type interval_timer =
            Unix.interval_timer =
              ITIMER_REAL
            | ITIMER_VIRTUAL
            | ITIMER_PROF
          type interval_timer_status =
            Unix.interval_timer_status = {
            it_interval : float;
            it_value : float;
          }
          val getitimer : interval_timer -> interval_timer_status
          val setitimer :
            interval_timer -> interval_timer_status -> interval_timer_status
          val getuid : unit -> int
          val geteuid : unit -> int
          val setuid : int -> unit
          val getgid : unit -> int
          val getegid : unit -> int
          val setgid : int -> unit
          val getgroups : unit -> int array
          val setgroups : int array -> unit
          val initgroups : string -> int -> unit
          type passwd_entry =
            Unix.passwd_entry = {
            pw_name : string;
            pw_passwd : string;
            pw_uid : int;
            pw_gid : int;
            pw_gecos : string;
            pw_dir : string;
            pw_shell : string;
          }
          type group_entry =
            Unix.group_entry = {
            gr_name : string;
            gr_passwd : string;
            gr_gid : int;
            gr_mem : string array;
          }
          val getlogin : unit -> string
          val getpwnam : string -> passwd_entry
          val getgrnam : string -> group_entry
          val getpwuid : int -> passwd_entry
          val getgrgid : int -> group_entry
          type inet_addr = Unix.inet_addr
          val inet_addr_of_string : string -> inet_addr
          val string_of_inet_addr : inet_addr -> string
          val inet_addr_any : inet_addr
          val inet_addr_loopback : inet_addr
          val inet6_addr_any : inet_addr
          val inet6_addr_loopback : inet_addr
          type socket_domain =
            Unix.socket_domain =
              PF_UNIX
            | PF_INET
            | PF_INET6
          type socket_type =
            Unix.socket_type =
              SOCK_STREAM
            | SOCK_DGRAM
            | SOCK_RAW
            | SOCK_SEQPACKET
          type sockaddr =
            Unix.sockaddr =
              ADDR_UNIX of string
            | ADDR_INET of inet_addr * int
          val socket : socket_domain -> socket_type -> int -> file_descr
          val domain_of_sockaddr : sockaddr -> socket_domain
          val socketpair :
            socket_domain -> socket_type -> int -> file_descr * file_descr
          val accept : file_descr -> file_descr * sockaddr
          val bind : file_descr -> sockaddr -> unit
          val connect : file_descr -> sockaddr -> unit
          val listen : file_descr -> int -> unit
          type shutdown_command =
            Unix.shutdown_command =
              SHUTDOWN_RECEIVE
            | SHUTDOWN_SEND
            | SHUTDOWN_ALL
          val shutdown : file_descr -> shutdown_command -> unit
          val getsockname : file_descr -> sockaddr
          val getpeername : file_descr -> sockaddr
          type msg_flag = Unix.msg_flag = MSG_OOB | MSG_DONTROUTE | MSG_PEEK
          val recv :
            file_descr -> string -> int -> int -> msg_flag list -> int
          val recvfrom :
            file_descr ->
            string -> int -> int -> msg_flag list -> int * sockaddr
          val send :
            file_descr -> string -> int -> int -> msg_flag list -> int
          val sendto :
            file_descr ->
            string -> int -> int -> msg_flag list -> sockaddr -> int
          type socket_bool_option =
            Unix.socket_bool_option =
              SO_DEBUG
            | SO_BROADCAST
            | SO_REUSEADDR
            | SO_KEEPALIVE
            | SO_DONTROUTE
            | SO_OOBINLINE
            | SO_ACCEPTCONN
            | TCP_NODELAY
            | IPV6_ONLY
          type socket_int_option =
            Unix.socket_int_option =
              SO_SNDBUF
            | SO_RCVBUF
            | SO_ERROR
            | SO_TYPE
            | SO_RCVLOWAT
            | SO_SNDLOWAT
          type socket_optint_option = Unix.socket_optint_option = SO_LINGER
          type socket_float_option =
            Unix.socket_float_option =
              SO_RCVTIMEO
            | SO_SNDTIMEO
          val getsockopt : file_descr -> socket_bool_option -> bool
          val setsockopt : file_descr -> socket_bool_option -> bool -> unit
          val getsockopt_int : file_descr -> socket_int_option -> int
          val setsockopt_int : file_descr -> socket_int_option -> int -> unit
          val getsockopt_optint :
            file_descr -> socket_optint_option -> int option
          val setsockopt_optint :
            file_descr -> socket_optint_option -> int option -> unit
          val getsockopt_float : file_descr -> socket_float_option -> float
          val setsockopt_float :
            file_descr -> socket_float_option -> float -> unit
          val getsockopt_error : file_descr -> error option
          val open_connection : sockaddr -> in_channel * out_channel
          val shutdown_connection : in_channel -> unit
          val establish_server :
            (in_channel -> out_channel -> unit) -> sockaddr -> unit
          type host_entry =
            Unix.host_entry = {
            h_name : string;
            h_aliases : string array;
            h_addrtype : socket_domain;
            h_addr_list : inet_addr array;
          }
          type protocol_entry =
            Unix.protocol_entry = {
            p_name : string;
            p_aliases : string array;
            p_proto : int;
          }
          type service_entry =
            Unix.service_entry = {
            s_name : string;
            s_aliases : string array;
            s_port : int;
            s_proto : string;
          }
          val gethostname : unit -> string
          val gethostbyname : string -> host_entry
          val gethostbyaddr : inet_addr -> host_entry
          val getprotobyname : string -> protocol_entry
          val getprotobynumber : int -> protocol_entry
          val getservbyname : string -> string -> service_entry
          val getservbyport : int -> string -> service_entry
          type addr_info =
            Unix.addr_info = {
            ai_family : socket_domain;
            ai_socktype : socket_type;
            ai_protocol : int;
            ai_addr : sockaddr;
            ai_canonname : string;
          }
          type getaddrinfo_option =
            Unix.getaddrinfo_option =
              AI_FAMILY of socket_domain
            | AI_SOCKTYPE of socket_type
            | AI_PROTOCOL of int
            | AI_NUMERICHOST
            | AI_CANONNAME
            | AI_PASSIVE
          val getaddrinfo :
            string -> string -> getaddrinfo_option list -> addr_info list
          type name_info =
            Unix.name_info = {
            ni_hostname : string;
            ni_service : string;
          }
          type getnameinfo_option =
            Unix.getnameinfo_option =
              NI_NOFQDN
            | NI_NUMERICHOST
            | NI_NAMEREQD
            | NI_NUMERICSERV
            | NI_DGRAM
          val getnameinfo : sockaddr -> getnameinfo_option list -> name_info
          type terminal_io =
            Unix.terminal_io = {
            mutable c_ignbrk : bool;
            mutable c_brkint : bool;
            mutable c_ignpar : bool;
            mutable c_parmrk : bool;
            mutable c_inpck : bool;
            mutable c_istrip : bool;
            mutable c_inlcr : bool;
            mutable c_igncr : bool;
            mutable c_icrnl : bool;
            mutable c_ixon : bool;
            mutable c_ixoff : bool;
            mutable c_opost : bool;
            mutable c_obaud : int;
            mutable c_ibaud : int;
            mutable c_csize : int;
            mutable c_cstopb : int;
            mutable c_cread : bool;
            mutable c_parenb : bool;
            mutable c_parodd : bool;
            mutable c_hupcl : bool;
            mutable c_clocal : bool;
            mutable c_isig : bool;
            mutable c_icanon : bool;
            mutable c_noflsh : bool;
            mutable c_echo : bool;
            mutable c_echoe : bool;
            mutable c_echok : bool;
            mutable c_echonl : bool;
            mutable c_vintr : char;
            mutable c_vquit : char;
            mutable c_verase : char;
            mutable c_vkill : char;
            mutable c_veof : char;
            mutable c_veol : char;
            mutable c_vmin : int;
            mutable c_vtime : int;
            mutable c_vstart : char;
            mutable c_vstop : char;
          }
          val tcgetattr : file_descr -> terminal_io
          type setattr_when =
            Unix.setattr_when =
              TCSANOW
            | TCSADRAIN
            | TCSAFLUSH
          val tcsetattr : file_descr -> setattr_when -> terminal_io -> unit
          val tcsendbreak : file_descr -> int -> unit
          val tcdrain : file_descr -> unit
          type flush_queue =
            Unix.flush_queue =
              TCIFLUSH
            | TCOFLUSH
            | TCIOFLUSH
          val tcflush : file_descr -> flush_queue -> unit
          type flow_action =
            Unix.flow_action =
              TCOOFF
            | TCOON
            | TCIOFF
            | TCION
          val tcflow : file_descr -> flow_action -> unit
          val setsid : unit -> int
        end
      module UnixLabels :
        sig
          type error =
            Unix.error =
              E2BIG
            | EACCES
            | EAGAIN
            | EBADF
            | EBUSY
            | ECHILD
            | EDEADLK
            | EDOM
            | EEXIST
            | EFAULT
            | EFBIG
            | EINTR
            | EINVAL
            | EIO
            | EISDIR
            | EMFILE
            | EMLINK
            | ENAMETOOLONG
            | ENFILE
            | ENODEV
            | ENOENT
            | ENOEXEC
            | ENOLCK
            | ENOMEM
            | ENOSPC
            | ENOSYS
            | ENOTDIR
            | ENOTEMPTY
            | ENOTTY
            | ENXIO
            | EPERM
            | EPIPE
            | ERANGE
            | EROFS
            | ESPIPE
            | ESRCH
            | EXDEV
            | EWOULDBLOCK
            | EINPROGRESS
            | EALREADY
            | ENOTSOCK
            | EDESTADDRREQ
            | EMSGSIZE
            | EPROTOTYPE
            | ENOPROTOOPT
            | EPROTONOSUPPORT
            | ESOCKTNOSUPPORT
            | EOPNOTSUPP
            | EPFNOSUPPORT
            | EAFNOSUPPORT
            | EADDRINUSE
            | EADDRNOTAVAIL
            | ENETDOWN
            | ENETUNREACH
            | ENETRESET
            | ECONNABORTED
            | ECONNRESET
            | ENOBUFS
            | EISCONN
            | ENOTCONN
            | ESHUTDOWN
            | ETOOMANYREFS
            | ETIMEDOUT
            | ECONNREFUSED
            | EHOSTDOWN
            | EHOSTUNREACH
            | ELOOP
            | EOVERFLOW
            | EUNKNOWNERR of int
          exception Unix_error of error * string * string
          val error_message : error -> string
          val handle_unix_error : ('a -> 'b) -> 'a -> 'b
          val environment : unit -> string array
          val getenv : string -> string
          val putenv : string -> string -> unit
          type process_status =
            Unix.process_status =
              WEXITED of int
            | WSIGNALED of int
            | WSTOPPED of int
          type wait_flag = Unix.wait_flag = WNOHANG | WUNTRACED
          val execv : prog:string -> args:string array -> 'a
          val execve :
            prog:string -> args:string array -> env:string array -> 'a
          val execvp : prog:string -> args:string array -> 'a
          val execvpe :
            prog:string -> args:string array -> env:string array -> 'a
          val fork : unit -> int
          val wait : unit -> int * process_status
          val waitpid : mode:wait_flag list -> int -> int * process_status
          val system : string -> process_status
          val getpid : unit -> int
          val getppid : unit -> int
          val nice : int -> int
          type file_descr = Unix.file_descr
          val stdin : file_descr
          val stdout : file_descr
          val stderr : file_descr
          type open_flag =
            Unix.open_flag =
              O_RDONLY
            | O_WRONLY
            | O_RDWR
            | O_NONBLOCK
            | O_APPEND
            | O_CREAT
            | O_TRUNC
            | O_EXCL
            | O_NOCTTY
            | O_DSYNC
            | O_SYNC
            | O_RSYNC
            | O_SHARE_DELETE
            | O_CLOEXEC
          type file_perm = int
          val openfile :
            string -> mode:open_flag list -> perm:file_perm -> file_descr
          val close : file_descr -> unit
          val read : file_descr -> buf:string -> pos:int -> len:int -> int
          val write : file_descr -> buf:string -> pos:int -> len:int -> int
          val single_write :
            file_descr -> buf:string -> pos:int -> len:int -> int
          val in_channel_of_descr : file_descr -> in_channel
          val out_channel_of_descr : file_descr -> out_channel
          val descr_of_in_channel : in_channel -> file_descr
          val descr_of_out_channel : out_channel -> file_descr
          type seek_command =
            Unix.seek_command =
              SEEK_SET
            | SEEK_CUR
            | SEEK_END
          val lseek : file_descr -> int -> mode:seek_command -> int
          val truncate : string -> len:int -> unit
          val ftruncate : file_descr -> len:int -> unit
          type file_kind =
            Unix.file_kind =
              S_REG
            | S_DIR
            | S_CHR
            | S_BLK
            | S_LNK
            | S_FIFO
            | S_SOCK
          type stats =
            Unix.stats = {
            st_dev : int;
            st_ino : int;
            st_kind : file_kind;
            st_perm : file_perm;
            st_nlink : int;
            st_uid : int;
            st_gid : int;
            st_rdev : int;
            st_size : int;
            st_atime : float;
            st_mtime : float;
            st_ctime : float;
          }
          val stat : string -> stats
          val lstat : string -> stats
          val fstat : file_descr -> stats
          val isatty : file_descr -> bool
          module LargeFile :
            sig
              val lseek : file_descr -> int64 -> mode:seek_command -> int64
              val truncate : string -> len:int64 -> unit
              val ftruncate : file_descr -> len:int64 -> unit
              type stats =
                Unix.LargeFile.stats = {
                st_dev : int;
                st_ino : int;
                st_kind : file_kind;
                st_perm : file_perm;
                st_nlink : int;
                st_uid : int;
                st_gid : int;
                st_rdev : int;
                st_size : int64;
                st_atime : float;
                st_mtime : float;
                st_ctime : float;
              }
              val stat : string -> stats
              val lstat : string -> stats
              val fstat : file_descr -> stats
            end
          val unlink : string -> unit
          val rename : src:string -> dst:string -> unit
          val link : src:string -> dst:string -> unit
          type access_permission =
            Unix.access_permission =
              R_OK
            | W_OK
            | X_OK
            | F_OK
          val chmod : string -> perm:file_perm -> unit
          val fchmod : file_descr -> perm:file_perm -> unit
          val chown : string -> uid:int -> gid:int -> unit
          val fchown : file_descr -> uid:int -> gid:int -> unit
          val umask : int -> int
          val access : string -> perm:access_permission list -> unit
          val dup : file_descr -> file_descr
          val dup2 : src:file_descr -> dst:file_descr -> unit
          val set_nonblock : file_descr -> unit
          val clear_nonblock : file_descr -> unit
          val set_close_on_exec : file_descr -> unit
          val clear_close_on_exec : file_descr -> unit
          val mkdir : string -> perm:file_perm -> unit
          val rmdir : string -> unit
          val chdir : string -> unit
          val getcwd : unit -> string
          val chroot : string -> unit
          type dir_handle = Unix.dir_handle
          val opendir : string -> dir_handle
          val readdir : dir_handle -> string
          val rewinddir : dir_handle -> unit
          val closedir : dir_handle -> unit
          val pipe : unit -> file_descr * file_descr
          val mkfifo : string -> perm:file_perm -> unit
          val create_process :
            prog:string ->
            args:string array ->
            stdin:file_descr -> stdout:file_descr -> stderr:file_descr -> int
          val create_process_env :
            prog:string ->
            args:string array ->
            env:string array ->
            stdin:file_descr -> stdout:file_descr -> stderr:file_descr -> int
          val open_process_in : string -> in_channel
          val open_process_out : string -> out_channel
          val open_process : string -> in_channel * out_channel
          val open_process_full :
            string ->
            env:string array -> in_channel * out_channel * in_channel
          val close_process_in : in_channel -> process_status
          val close_process_out : out_channel -> process_status
          val close_process : in_channel * out_channel -> process_status
          val close_process_full :
            in_channel * out_channel * in_channel -> process_status
          val symlink : src:string -> dst:string -> unit
          val readlink : string -> string
          val select :
            read:file_descr list ->
            write:file_descr list ->
            except:file_descr list ->
            timeout:float ->
            file_descr list * file_descr list * file_descr list
          type lock_command =
            Unix.lock_command =
              F_ULOCK
            | F_LOCK
            | F_TLOCK
            | F_TEST
            | F_RLOCK
            | F_TRLOCK
          val lockf : file_descr -> mode:lock_command -> len:int -> unit
          val kill : pid:int -> signal:int -> unit
          type sigprocmask_command =
            Unix.sigprocmask_command =
              SIG_SETMASK
            | SIG_BLOCK
            | SIG_UNBLOCK
          val sigprocmask : mode:sigprocmask_command -> int list -> int list
          val sigpending : unit -> int list
          val sigsuspend : int list -> unit
          val pause : unit -> unit
          type process_times =
            Unix.process_times = {
            tms_utime : float;
            tms_stime : float;
            tms_cutime : float;
            tms_cstime : float;
          }
          type tm =
            Unix.tm = {
            tm_sec : int;
            tm_min : int;
            tm_hour : int;
            tm_mday : int;
            tm_mon : int;
            tm_year : int;
            tm_wday : int;
            tm_yday : int;
            tm_isdst : bool;
          }
          val time : unit -> float
          val gettimeofday : unit -> float
          val gmtime : float -> tm
          val localtime : float -> tm
          val mktime : tm -> float * tm
          val alarm : int -> int
          val sleep : int -> unit
          val times : unit -> process_times
          val utimes : string -> access:float -> modif:float -> unit
          type interval_timer =
            Unix.interval_timer =
              ITIMER_REAL
            | ITIMER_VIRTUAL
            | ITIMER_PROF
          type interval_timer_status =
            Unix.interval_timer_status = {
            it_interval : float;
            it_value : float;
          }
          val getitimer : interval_timer -> interval_timer_status
          val setitimer :
            interval_timer -> interval_timer_status -> interval_timer_status
          val getuid : unit -> int
          val geteuid : unit -> int
          val setuid : int -> unit
          val getgid : unit -> int
          val getegid : unit -> int
          val setgid : int -> unit
          val getgroups : unit -> int array
          val setgroups : int array -> unit
          val initgroups : string -> int -> unit
          type passwd_entry =
            Unix.passwd_entry = {
            pw_name : string;
            pw_passwd : string;
            pw_uid : int;
            pw_gid : int;
            pw_gecos : string;
            pw_dir : string;
            pw_shell : string;
          }
          type group_entry =
            Unix.group_entry = {
            gr_name : string;
            gr_passwd : string;
            gr_gid : int;
            gr_mem : string array;
          }
          val getlogin : unit -> string
          val getpwnam : string -> passwd_entry
          val getgrnam : string -> group_entry
          val getpwuid : int -> passwd_entry
          val getgrgid : int -> group_entry
          type inet_addr = Unix.inet_addr
          val inet_addr_of_string : string -> inet_addr
          val string_of_inet_addr : inet_addr -> string
          val inet_addr_any : inet_addr
          val inet_addr_loopback : inet_addr
          val inet6_addr_any : inet_addr
          val inet6_addr_loopback : inet_addr
          type socket_domain =
            Unix.socket_domain =
              PF_UNIX
            | PF_INET
            | PF_INET6
          type socket_type =
            Unix.socket_type =
              SOCK_STREAM
            | SOCK_DGRAM
            | SOCK_RAW
            | SOCK_SEQPACKET
          type sockaddr =
            Unix.sockaddr =
              ADDR_UNIX of string
            | ADDR_INET of inet_addr * int
          val socket :
            domain:socket_domain ->
            kind:socket_type -> protocol:int -> file_descr
          val domain_of_sockaddr : sockaddr -> socket_domain
          val socketpair :
            domain:socket_domain ->
            kind:socket_type -> protocol:int -> file_descr * file_descr
          val accept : file_descr -> file_descr * sockaddr
          val bind : file_descr -> addr:sockaddr -> unit
          val connect : file_descr -> addr:sockaddr -> unit
          val listen : file_descr -> max:int -> unit
          type shutdown_command =
            Unix.shutdown_command =
              SHUTDOWN_RECEIVE
            | SHUTDOWN_SEND
            | SHUTDOWN_ALL
          val shutdown : file_descr -> mode:shutdown_command -> unit
          val getsockname : file_descr -> sockaddr
          val getpeername : file_descr -> sockaddr
          type msg_flag = Unix.msg_flag = MSG_OOB | MSG_DONTROUTE | MSG_PEEK
          val recv :
            file_descr ->
            buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
          val recvfrom :
            file_descr ->
            buf:string ->
            pos:int -> len:int -> mode:msg_flag list -> int * sockaddr
          val send :
            file_descr ->
            buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
          val sendto :
            file_descr ->
            buf:string ->
            pos:int -> len:int -> mode:msg_flag list -> addr:sockaddr -> int
          type socket_bool_option =
            UnixLabels.socket_bool_option =
              SO_DEBUG
            | SO_BROADCAST
            | SO_REUSEADDR
            | SO_KEEPALIVE
            | SO_DONTROUTE
            | SO_OOBINLINE
            | SO_ACCEPTCONN
            | TCP_NODELAY
            | IPV6_ONLY
          type socket_int_option =
            UnixLabels.socket_int_option =
              SO_SNDBUF
            | SO_RCVBUF
            | SO_ERROR
            | SO_TYPE
            | SO_RCVLOWAT
            | SO_SNDLOWAT
          type socket_optint_option =
            UnixLabels.socket_optint_option =
              SO_LINGER
          type socket_float_option =
            UnixLabels.socket_float_option =
              SO_RCVTIMEO
            | SO_SNDTIMEO
          val getsockopt : file_descr -> socket_bool_option -> bool
          val setsockopt : file_descr -> socket_bool_option -> bool -> unit
          val getsockopt_int : file_descr -> socket_int_option -> int
          val setsockopt_int : file_descr -> socket_int_option -> int -> unit
          val getsockopt_optint :
            file_descr -> socket_optint_option -> int option
          val setsockopt_optint :
            file_descr -> socket_optint_option -> int option -> unit
          val getsockopt_float : file_descr -> socket_float_option -> float
          val setsockopt_float :
            file_descr -> socket_float_option -> float -> unit
          val getsockopt_error : file_descr -> error option
          val open_connection : sockaddr -> in_channel * out_channel
          val shutdown_connection : in_channel -> unit
          val establish_server :
            (in_channel -> out_channel -> unit) -> addr:sockaddr -> unit
          type host_entry =
            Unix.host_entry = {
            h_name : string;
            h_aliases : string array;
            h_addrtype : socket_domain;
            h_addr_list : inet_addr array;
          }
          type protocol_entry =
            Unix.protocol_entry = {
            p_name : string;
            p_aliases : string array;
            p_proto : int;
          }
          type service_entry =
            Unix.service_entry = {
            s_name : string;
            s_aliases : string array;
            s_port : int;
            s_proto : string;
          }
          val gethostname : unit -> string
          val gethostbyname : string -> host_entry
          val gethostbyaddr : inet_addr -> host_entry
          val getprotobyname : string -> protocol_entry
          val getprotobynumber : int -> protocol_entry
          val getservbyname : string -> protocol:string -> service_entry
          val getservbyport : int -> protocol:string -> service_entry
          type addr_info =
            UnixLabels.addr_info = {
            ai_family : socket_domain;
            ai_socktype : socket_type;
            ai_protocol : int;
            ai_addr : sockaddr;
            ai_canonname : string;
          }
          type getaddrinfo_option =
            UnixLabels.getaddrinfo_option =
              AI_FAMILY of socket_domain
            | AI_SOCKTYPE of socket_type
            | AI_PROTOCOL of int
            | AI_NUMERICHOST
            | AI_CANONNAME
            | AI_PASSIVE
          val getaddrinfo :
            string -> string -> getaddrinfo_option list -> addr_info list
          type name_info =
            UnixLabels.name_info = {
            ni_hostname : string;
            ni_service : string;
          }
          type getnameinfo_option =
            UnixLabels.getnameinfo_option =
              NI_NOFQDN
            | NI_NUMERICHOST
            | NI_NAMEREQD
            | NI_NUMERICSERV
            | NI_DGRAM
          val getnameinfo : sockaddr -> getnameinfo_option list -> name_info
          type terminal_io =
            Unix.terminal_io = {
            mutable c_ignbrk : bool;
            mutable c_brkint : bool;
            mutable c_ignpar : bool;
            mutable c_parmrk : bool;
            mutable c_inpck : bool;
            mutable c_istrip : bool;
            mutable c_inlcr : bool;
            mutable c_igncr : bool;
            mutable c_icrnl : bool;
            mutable c_ixon : bool;
            mutable c_ixoff : bool;
            mutable c_opost : bool;
            mutable c_obaud : int;
            mutable c_ibaud : int;
            mutable c_csize : int;
            mutable c_cstopb : int;
            mutable c_cread : bool;
            mutable c_parenb : bool;
            mutable c_parodd : bool;
            mutable c_hupcl : bool;
            mutable c_clocal : bool;
            mutable c_isig : bool;
            mutable c_icanon : bool;
            mutable c_noflsh : bool;
            mutable c_echo : bool;
            mutable c_echoe : bool;
            mutable c_echok : bool;
            mutable c_echonl : bool;
            mutable c_vintr : char;
            mutable c_vquit : char;
            mutable c_verase : char;
            mutable c_vkill : char;
            mutable c_veof : char;
            mutable c_veol : char;
            mutable c_vmin : int;
            mutable c_vtime : int;
            mutable c_vstart : char;
            mutable c_vstop : char;
          }
          val tcgetattr : file_descr -> terminal_io
          type setattr_when =
            Unix.setattr_when =
              TCSANOW
            | TCSADRAIN
            | TCSAFLUSH
          val tcsetattr :
            file_descr -> mode:setattr_when -> terminal_io -> unit
          val tcsendbreak : file_descr -> duration:int -> unit
          val tcdrain : file_descr -> unit
          type flush_queue =
            Unix.flush_queue =
              TCIFLUSH
            | TCOFLUSH
            | TCIOFLUSH
          val tcflush : file_descr -> mode:flush_queue -> unit
          type flow_action =
            Unix.flow_action =
              TCOOFF
            | TCOON
            | TCIOFF
            | TCION
          val tcflow : file_descr -> mode:flow_action -> unit
          val setsid : unit -> int
        end
    end
  module Char :
    sig
      type t = char
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Core_char.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Core_char.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      val to_int : t -> int
      val of_int : int -> t option
      val of_int_exn : int -> t
      val unsafe_of_int : int -> t
      val escaped : t -> string
      val lowercase : t -> t
      val uppercase : t -> t
      val is_digit : t -> bool
      val is_lowercase : t -> bool
      val is_uppercase : t -> bool
      val is_alpha : t -> bool
      val is_alphanum : t -> bool
      val is_print : t -> bool
      val is_whitespace : t -> bool
      val get_digit : t -> int option
      val get_digit_exn : t -> int
      val min_value : t
      val max_value : t
      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
  module Command :
    sig
      module Spec :
        sig
          type 'a param = 'a Core.Command.Spec.param
          val const : 'a -> 'a param
          val map : 'a param -> f:('a -> 'b) -> 'b param
          val help : string Core_kernel.Std.Lazy.t param
          val path : string list param
          val args : string list param
          type ('main_in, 'main_out) t =
              ('main_in, 'main_out) Core.Command.Spec.t
          val empty : ('m, 'm) t
          val ( ++ ) : ('m1, 'm2) t -> ('m2, 'm3) t -> ('m1, 'm3) t
          val ( +> ) : ('m1, 'a -> 'm2) t -> 'a param -> ('m1, 'm2) t
          val ( +< ) : ('m1, 'm2) t -> 'a param -> ('a -> 'm1, 'm2) t
          val step : ('m1 -> 'm2) -> ('m1, 'm2) t
          val wrap :
            (run:('m1 -> 'r1) -> main:'m2 -> 'r2) ->
            ('m1, 'r1) t -> ('m2, 'r2) t
          module Arg_type :
            sig
              type 'a t = 'a Core.Command.Spec.Arg_type.t
              val create :
                ?complete:(Core_kernel.Std.Univ_map.t ->
                           part:string -> string list) ->
                ?key:'a Core_kernel.Std.Univ_map.Multi.Key.t ->
                (string -> 'a) -> 'a t
              val of_map :
                ?key:'a Core_kernel.Std.Univ_map.Multi.Key.t ->
                'a Core_kernel.Std.String.Map.t -> 'a t
              val of_alist_exn :
                ?key:'a Core_kernel.Std.Univ_map.Multi.Key.t ->
                (string * 'a) list -> 'a t
            end
          val string : string Arg_type.t
          val int : int Arg_type.t
          val float : float Arg_type.t
          val bool : bool Arg_type.t
          val date : Core.Date.t Arg_type.t
          val time_span : Core.Span.t Arg_type.t
          val file : string Arg_type.t
          type 'a flag = 'a Core.Command.Spec.flag
          val flag :
            ?aliases:string list ->
            string -> 'a flag -> doc:string -> 'a param
          val required : 'a Arg_type.t -> 'a flag
          val optional : 'a Arg_type.t -> 'a option flag
          val optional_with_default : 'a -> 'a Arg_type.t -> 'a flag
          val listed : 'a Arg_type.t -> 'a list flag
          val no_arg : bool flag
          val no_arg_register :
            key:'a Core_kernel.Std.Univ_map.With_default.Key.t ->
            value:'a -> bool flag
          val no_arg_abort :
            exit:(unit -> Core_kernel.Std.never_returns) -> unit flag
          val escape : string list option flag
          val flags_of_args_exn : Core_kernel.Std.Arg.t list -> ('a, 'a) t
          type 'a anons = 'a Core.Command.Spec.anons
          val anon : 'a anons -> 'a param
          val ( %: ) : string -> 'a Arg_type.t -> 'a anons
          val sequence : 'a anons -> 'a list anons
          val maybe : 'a anons -> 'a option anons
          val maybe_with_default : 'a -> 'a anons -> 'a anons
          val t2 : 'a anons -> 'b anons -> ('a * 'b) anons
          val t3 : 'a anons -> 'b anons -> 'c anons -> ('a * 'b * 'c) anons
          val t4 :
            'a anons ->
            'b anons -> 'c anons -> 'd anons -> ('a * 'b * 'c * 'd) anons
        end
      type t = Core.Command.t
      val basic :
        summary:string ->
        ?readme:(unit -> string) ->
        ('main, unit -> unit) Spec.t -> 'main -> t
      val group :
        summary:string -> ?readme:(unit -> string) -> (string * t) list -> t
      val run :
        ?version:string ->
        ?build_info:string ->
        ?argv:string list ->
        ?extend:(string list -> string list) -> t -> unit
      module Deprecated :
        sig
          module Spec :
            sig
              val no_arg : hook:(unit -> unit) -> bool Spec.flag
              val escape :
                hook:(string list -> unit) -> string list option Spec.flag
              val ad_hoc : usage_arg:string -> string list Spec.anons
            end
          val summary : t -> string
          val help_recursive :
            cmd:string ->
            with_flags:bool ->
            expand_dots:bool -> t -> string -> (string * string) list
          val run :
            t ->
            cmd:string ->
            args:string list ->
            is_help:bool ->
            is_help_rec:bool ->
            is_help_rec_flags:bool -> is_expand_dots:bool -> unit
          val get_flag_names : t -> string list
          val version : string
          val build_info : string
        end
    end
  module Dequeue :
    sig
      type 'a t = 'a Core_kernel.Dequeue.t
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val count : 'a t -> f:('a -> bool) -> int
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val create : ?initial_length:int -> ?never_shrink:bool -> unit -> 'a t
      val front_index : 'a t -> int option
      val front_index_exn : 'a t -> int
      val back_index : 'a t -> int option
      val back_index_exn : 'a t -> int
      val get : 'a t -> int -> 'a option
      val get_exn : 'a t -> int -> 'a
      val peek : 'a t -> [ `back | `front ] -> 'a option
      val peek_front : 'a t -> 'a option
      val peek_front_exn : 'a t -> 'a
      val peek_back : 'a t -> 'a option
      val peek_back_exn : 'a t -> 'a
      val set_exn : 'a t -> int -> 'a -> unit
      val iter' :
        'a t -> [ `back_to_front | `front_to_back ] -> f:('a -> unit) -> unit
      val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
      val iteri' :
        'a t ->
        [ `back_to_front | `front_to_back ] -> f:(int -> 'a -> unit) -> unit
      val fold' :
        'a t ->
        [ `back_to_front | `front_to_back ] ->
        init:'b -> f:('b -> 'a -> 'b) -> 'b
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
      val foldi' :
        'a t ->
        [ `back_to_front | `front_to_back ] ->
        init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
      val enqueue : 'a t -> [ `back | `front ] -> 'a -> unit
      val enqueue_front : 'a t -> 'a -> unit
      val enqueue_back : 'a t -> 'a -> unit
      val clear : 'a t -> unit
      val drop : ?n:int -> 'a t -> [ `back | `front ] -> unit
      val drop_front : ?n:int -> 'a t -> unit
      val drop_back : ?n:int -> 'a t -> unit
      val dequeue : 'a t -> [ `back | `front ] -> 'a option
      val dequeue_exn : 'a t -> [ `back | `front ] -> 'a
      val dequeue_front : 'a t -> 'a option
      val dequeue_front_exn : 'a t -> 'a
      val dequeue_back : 'a t -> 'a option
      val dequeue_back_exn : 'a t -> 'a
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
    end
  module Exn :
    sig
      type t = exn
      val pp : Format.formatter -> t -> unit
      exception Finally of t * t
      exception Reraised of string * t
      val reraise : t -> string -> 'a
      val reraisef : t -> ('a, unit, string, unit -> 'b) format4 -> 'a
      val to_string : t -> string
      val to_string_mach : t -> string
      val protectx : f:('a -> 'b) -> 'a -> finally:('a -> unit) -> 'b
      val protect : f:(unit -> 'a) -> finally:(unit -> unit) -> 'a
      val handle_uncaught : exit:bool -> (unit -> unit) -> unit
      val handle_uncaught_and_exit :
        (unit -> Core_kernel.Never_returns.never_returns) ->
        Core_kernel.Never_returns.never_returns
      val reraise_uncaught : string -> (unit -> 'a) -> 'a
      val backtrace : unit -> string
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Filename :
    sig
      val root : string
      val realpath : string -> string
      val is_posix_pathname_component : string -> bool
      val temp_file :
        ?perm:int -> ?in_dir:string -> string -> string -> string
      val temp_dir :
        ?perm:int -> ?in_dir:string -> string -> string -> string
      val temp_dir_name : string
      val open_temp_file :
        ?perm:int ->
        ?in_dir:string -> string -> string -> string * out_channel
      val current_dir_name : string
      val parent_dir_name : string
      val dir_sep : string
      val concat : string -> string -> string
      val is_relative : string -> bool
      val is_absolute : string -> bool
      val is_implicit : string -> bool
      val check_suffix : string -> string -> bool
      val chop_suffix : string -> string -> string
      val chop_extension : string -> string
      val split_extension : string -> string * string option
      val basename : string -> string
      val dirname : string -> string
      val split : string -> string * string
      val parts : string -> string list
      val quote : string -> string
      module Infix : sig val ( / ) : string -> string -> string end
    end
  module Float :
    sig
      type t = float
      type outer = t
      val of_float : float -> t
      val to_float : t -> float
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Float.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Float.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      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
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      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 robustly_compare : t -> t -> int
      val validate_ordinary : t Core_kernel.Validate.check
      val nan : t
      val infinity : t
      val neg_infinity : t
      val max_value : t
      val min_value : t
      val zero : t
      val epsilon : t
      val epsilon_float : t
      val max_finite_value : t
      val min_positive_value : t
      val of_int : int -> t
      val to_int : t -> int
      val of_int64 : int64 -> t
      val to_int64 : t -> int64
      val round : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> t -> t
      val iround : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> t -> int option
      val iround_exn : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> t -> int
      val round_towards_zero : t -> t
      val round_down : t -> t
      val round_up : t -> t
      val round_nearest : t -> t
      val iround_towards_zero : t -> int option
      val iround_down : t -> int option
      val iround_up : t -> int option
      val iround_nearest : t -> int option
      val iround_towards_zero_exn : t -> int
      val iround_down_exn : t -> int
      val iround_up_exn : t -> int
      val iround_nearest_exn : t -> int
      val is_nan : t -> bool
      val is_inf : t -> bool
      val min_inan : t -> t -> t
      val max_inan : t -> t -> t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      module Parts :
        sig
          type t = Core_kernel.Float.Parts.t
          val fractional : t -> outer
          val integral : t -> outer
        end
      val modf : t -> Parts.t
      val mod_float : t -> t -> t
      val add : t -> t -> t
      val sub : t -> t -> t
      val neg : t -> t
      val scale : t -> t -> t
      val abs : t -> t
      val to_string_hum :
        ?delimiter:char ->
        ?decimals:int -> ?strip_zero:bool -> float -> string
      val ldexp : t -> int -> t
      val frexp : t -> t * int
      module Class :
        sig
          type t =
            Core_kernel.Float.Class.t =
              Infinite
            | Nan
            | Normal
            | Subnormal
            | Zero
          val of_string : string -> t
          val to_string : t -> string
          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
      val classify : t -> Class.t
      val is_finite : t -> bool
      module Sign :
        sig
          type t = Core_kernel.Float.Sign.t = Neg | Zero | Pos
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      val sign : t -> Sign.t
      module Terse :
        sig
          type t = outer
          val of_string : string -> t
          val to_string : t -> string
          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
      val outer_of_sexp : Sexplib.Sexp.t -> outer
      val sexp_of_outer : outer -> Sexplib.Sexp.t
      val bin_outer : outer Bin_prot.Type_class.t
      val bin_read_outer : outer Bin_prot.Read_ml.reader
      val bin_read_outer_ : outer Bin_prot.Unsafe_read_c.reader
      val bin_read_outer__ : (int -> outer) Bin_prot.Unsafe_read_c.reader
      val bin_reader_outer : outer Bin_prot.Type_class.reader
      val bin_size_outer : outer Bin_prot.Size.sizer
      val bin_write_outer : outer Bin_prot.Write_ml.writer
      val bin_write_outer_ : outer Bin_prot.Unsafe_write_c.writer
      val bin_writer_outer : outer Bin_prot.Type_class.writer
    end
  module Fn :
    sig
      external ( |! ) : 'a -> ('a -> 'b) -> 'b = "%revapply"
      external ( |> ) : 'a -> ('a -> 'b) -> 'b = "%revapply"
      val const : 'a -> 'b -> 'a
      external ignore : 'a -> unit = "%ignore"
      val non : ('a -> bool) -> 'a -> bool
      val forever : (unit -> unit) -> exn
      val apply_n_times : n:int -> ('a -> 'a) -> 'a -> 'a
      external id : 'a -> 'a = "%identity"
      val compose : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c
      val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
    end
  module Hashtbl :
    sig
      module Hashable :
        sig
          type 'a t =
            'a Core_kernel.Core_hashtbl_intf.Hashable.t = {
            hash : 'a -> int;
            compare : 'a -> 'a -> int;
            sexp_of_t : 'a -> Sexplib.Sexp.t;
          }
          val poly : 'a t
          val of_key :
            (module Core_kernel.Core_hashtbl_intf.Key with type t = 'a) ->
            'a t
          val hash_param : int -> int -> 'a -> int
          val hash : 'a -> int
        end
      val hash : 'a -> int
      val hash_param : int -> int -> 'a -> int
      type ('a, 'b) t = ('a, 'b) Core_kernel.Core_hashtbl.t
      type 'a key = 'a
      val create :
        ('a key, unit -> ('a, 'b) t)
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val of_alist :
        ('a key,
         ('a key * 'b) list ->
         [ `Duplicate_key of 'a key | `Ok of ('a, 'b) t ])
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val of_alist_report_all_dups :
        ('a key,
         ('a key * 'b) list ->
         [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val of_alist_exn :
        ('a key, ('a key * 'b) list -> ('a, 'b) t)
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val of_alist_multi :
        ('a key, ('a key * 'b) list -> ('a, 'b list) t)
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val create_mapped :
        ('a key,
         get_key:('r -> 'a key) ->
         get_data:('r -> 'b) ->
         'r list -> [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val create_with_key :
        ('a key,
         get_key:('r -> 'a key) ->
         'r list -> [ `Duplicate_keys of 'a key list | `Ok of ('a, 'r) t ])
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val create_with_key_exn :
        ('a key, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t)
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val group :
        ('a key,
         get_key:('r -> 'a key) ->
         get_data:('r -> 'b) ->
         combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t)
        Core_kernel.Core_hashtbl_intf.create_options_with_hashable
      val sexp_of_key : ('a, 'b) t -> 'a key -> Sexplib.Sexp.t
      val clear : ('a, 'b) t -> unit
      val copy : ('a, 'b) t -> ('a, 'b) t
      val invariant : ('a, 'b) t -> unit
      val fold :
        ('a, 'b) t -> init:'c -> f:(key:'a key -> data:'b -> 'c -> 'c) -> 'c
      val iter : ('a, 'b) t -> f:(key:'a key -> data:'b -> unit) -> unit
      val existsi : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool
      val exists : ('a, 'b) t -> f:('b -> bool) -> bool
      val length : ('a, 'b) t -> int
      val is_empty : ('a, 'b) t -> bool
      val mem : ('a, 'b) t -> 'a key -> bool
      val remove : ('a, 'b) t -> 'a key -> unit
      val remove_one : ('a, 'b list) t -> 'a key -> unit
      val replace : ('a, 'b) t -> key:'a key -> data:'b -> unit
      val set : ('a, 'b) t -> key:'a key -> data:'b -> unit
      val add : ('a, 'b) t -> key:'a key -> data:'b -> [ `Duplicate | `Ok ]
      val add_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit
      val change : ('a, 'b) t -> 'a key -> ('b option -> 'b option) -> unit
      val add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit
      val remove_multi : ('a, 'b list) t -> 'a key -> unit
      val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
      val mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c) -> ('a, 'c) t
      val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t
      val filter_mapi :
        ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c option) -> ('a, 'c) t
      val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t
      val filteri :
        ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t
      val partition_map :
        ('a, 'b) t ->
        f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t * ('a, 'd) t
      val partition_mapi :
        ('a, 'b) t ->
        f:(key:'a key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
        ('a, 'c) t * ('a, 'd) t
      val partition_tf :
        ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t
      val partitioni_tf :
        ('a, 'b) t ->
        f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t * ('a, 'b) t
      val find_or_add : ('a, 'b) t -> 'a key -> default:(unit -> 'b) -> 'b
      val find : ('a, 'b) t -> 'a key -> 'b option
      val find_exn : ('a, 'b) t -> 'a key -> 'b
      val find_and_remove : ('a, 'b) t -> 'a key -> 'b option
      val iter_vals : ('a, 'b) t -> f:('b -> unit) -> unit
      val merge :
        ('k, 'a) t ->
        ('k, 'b) t ->
        f:(key:'k key ->
           [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
        ('k, 'c) t
      val merge_into :
        f:(key:'a key -> 'b -> 'b option -> 'b option) ->
        src:('a, 'b) t -> dst:('a, 'b) t -> unit
      val keys : ('a, 'b) t -> 'a key list
      val data : ('a, 'b) t -> 'b list
      val filter_inplace : ('a, 'b) t -> f:('b -> bool) -> unit
      val filteri_inplace : ('a, 'b) t -> f:('a key -> 'b -> bool) -> unit
      val equal : ('a, 'b) t -> ('a, 'b) t -> ('b -> 'b -> bool) -> bool
      val to_alist : ('a, 'b) t -> ('a key * 'b) list
      val validate :
        name:('a key -> string) ->
        'b Core_kernel.Validate.check ->
        ('a, 'b) t Core_kernel.Validate.check
      val incr : ?by:int -> ('a, int) t -> 'a key -> unit
      module Poly :
        sig
          type ('a, 'b) t = ('a, 'b) t
          val hashable : 'a Hashable.t
          type 'a key = 'a
          val create :
            ('a key, unit -> ('a, 'b) t)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key,
             ('a key * 'b) list ->
             [ `Duplicate_key of 'a key | `Ok of ('a, 'b) t ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key,
             ('a key * 'b) list ->
             [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key, ('a key * 'b) list -> ('a, 'b) t)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key, ('a key * 'b) list -> ('a, 'b list) t)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key,
             get_key:('r -> 'a key) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key,
             get_key:('r -> 'a key) ->
             'r list ->
             [ `Duplicate_keys of 'a key list | `Ok of ('a, 'r) t ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key,
             get_key:('r -> 'a key) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t -> 'a key -> Sexplib.Sexp.t
          val clear : ('a, 'b) t -> unit
          val copy : ('a, 'b) t -> ('a, 'b) t
          val invariant : ('a, 'b) t -> unit
          val fold :
            ('a, 'b) t ->
            init:'c -> f:(key:'a key -> data:'b -> 'c -> 'c) -> 'c
          val iter : ('a, 'b) t -> f:(key:'a key -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t -> f:('b -> bool) -> bool
          val length : ('a, 'b) t -> int
          val is_empty : ('a, 'b) t -> bool
          val mem : ('a, 'b) t -> 'a key -> bool
          val remove : ('a, 'b) t -> 'a key -> unit
          val remove_one : ('a, 'b list) t -> 'a key -> unit
          val replace : ('a, 'b) t -> key:'a key -> data:'b -> unit
          val set : ('a, 'b) t -> key:'a key -> data:'b -> unit
          val add :
            ('a, 'b) t -> key:'a key -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit
          val change :
            ('a, 'b) t -> 'a key -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit
          val remove_multi : ('a, 'b list) t -> 'a key -> unit
          val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
          val mapi :
            ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c) -> ('a, 'c) t
          val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t
          val filter_mapi :
            ('a, 'b) t ->
            f:(key:'a key -> data:'b -> 'c option) -> ('a, 'c) t
          val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t
          val filteri :
            ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t
          val partition_map :
            ('a, 'b) t ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t * ('a, 'd) t
          val partition_mapi :
            ('a, 'b) t ->
            f:(key:'a key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t * ('a, 'd) t
          val partition_tf :
            ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t
          val partitioni_tf :
            ('a, 'b) t ->
            f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t * ('a, 'b) t
          val find_or_add :
            ('a, 'b) t -> 'a key -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t -> 'a key -> 'b option
          val find_exn : ('a, 'b) t -> 'a key -> 'b
          val find_and_remove : ('a, 'b) t -> 'a key -> 'b option
          val iter_vals : ('a, 'b) t -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t ->
            ('k, 'b) t ->
            f:(key:'k key ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t
          val merge_into :
            f:(key:'a key -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t -> dst:('a, 'b) t -> unit
          val keys : ('a, 'b) t -> 'a key list
          val data : ('a, 'b) t -> 'b list
          val filter_inplace : ('a, 'b) t -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t -> f:('a key -> 'b -> bool) -> unit
          val equal : ('a, 'b) t -> ('a, 'b) t -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t -> ('a key * 'b) list
          val validate :
            name:('a key -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t -> 'a key -> unit
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'a) ->
            (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
          val bin_t :
            'a Bin_prot.Type_class.t ->
            'b Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
          val bin_read_t :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            ('a, 'b) t Bin_prot.Read_ml.reader
          val bin_read_t_ :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            ('a, 'b) t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            (int -> ('a, 'b) t) Bin_prot.Unsafe_read_c.reader
          val bin_reader_t :
            'a Bin_prot.Type_class.reader ->
            'b Bin_prot.Type_class.reader ->
            ('a, 'b) t Bin_prot.Type_class.reader
          val bin_size_t :
            'a Bin_prot.Size.sizer ->
            'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
          val bin_write_t :
            'a Bin_prot.Unsafe_write_c.writer ->
            'b Bin_prot.Unsafe_write_c.writer ->
            ('a, 'b) t Bin_prot.Write_ml.writer
          val bin_write_t_ :
            'a Bin_prot.Unsafe_write_c.writer ->
            'b Bin_prot.Unsafe_write_c.writer ->
            ('a, 'b) t Bin_prot.Unsafe_write_c.writer
          val bin_writer_t :
            'a Bin_prot.Type_class.writer ->
            'b Bin_prot.Type_class.writer ->
            ('a, 'b) t Bin_prot.Type_class.writer
        end
      module type Key = Core_kernel.Core_hashtbl_intf.Key
      module type Key_binable = Core_kernel.Core_hashtbl_intf.Key_binable
      module type S =
        sig
          type key
          type ('a, 'b) hashtbl = ('a, 'b) t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
        end
      module type S_binable =
        sig
          type key
          type ('a, 'b) hashtbl = ('a, 'b) t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Make :
        functor (Key : Key) ->
          sig
            type key = Key.t
            type ('a, 'b) hashtbl = ('a, 'b) t
            type 'b t = (key, 'b) hashtbl
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
            val create :
              ('a key_, unit -> ('a, 'b) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist :
              ('a key_,
               ('a key_ * 'b) list ->
               [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist_report_all_dups :
              ('a key_,
               ('a key_ * 'b) list ->
               [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val create_mapped :
              ('a key_,
               get_key:('r -> 'a key_) ->
               get_data:('r -> 'b) ->
               'r list ->
               [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val create_with_key :
              ('a key_,
               get_key:('r -> 'a key_) ->
               'r list ->
               [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val group :
              ('a key_,
               get_key:('r -> 'a key_) ->
               get_data:('r -> 'b) ->
               combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
            val clear : ('a, 'b) t_ -> unit
            val copy : ('a, 'b) t_ -> ('a, 'b) t_
            val invariant : ('a, 'b) t_ -> unit
            val fold :
              ('a, 'b) t_ ->
              init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
            val iter :
              ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
            val existsi :
              ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
            val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
            val length : ('a, 'b) t_ -> int
            val is_empty : ('a, 'b) t_ -> bool
            val mem : ('a, 'b) t_ -> 'a key_ -> bool
            val remove : ('a, 'b) t_ -> 'a key_ -> unit
            val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
            val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
            val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
            val add :
              ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
            val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
            val change :
              ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
            val add_multi :
              ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
            val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
            val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
            val mapi :
              ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
            val filter_map :
              ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
            val filter_mapi :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
            val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
            val filteri :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
            val partition_map :
              ('a, 'b) t_ ->
              f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
              ('a, 'c) t_ * ('a, 'd) t_
            val partition_mapi :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
              ('a, 'c) t_ * ('a, 'd) t_
            val partition_tf :
              ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
            val partitioni_tf :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
            val find_or_add :
              ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
            val find : ('a, 'b) t_ -> 'a key_ -> 'b option
            val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
            val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
            val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
            val merge :
              ('k, 'a) t_ ->
              ('k, 'b) t_ ->
              f:(key:'k key_ ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              ('k, 'c) t_
            val merge_into :
              f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
              src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
            val keys : ('a, 'b) t_ -> 'a key_ list
            val data : ('a, 'b) t_ -> 'b list
            val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
            val filteri_inplace :
              ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
            val equal :
              ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
            val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
            val validate :
              name:('a key_ -> string) ->
              'b Core_kernel.Validate.check ->
              ('a, 'b) t_ Core_kernel.Validate.check
            val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
            val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
            val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          end
      module Make_binable :
        functor (Key : Key_binable) ->
          sig
            type key = Key.t
            type ('a, 'b) hashtbl = ('a, 'b) t
            type 'b t = (key, 'b) hashtbl
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
            val create :
              ('a key_, unit -> ('a, 'b) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist :
              ('a key_,
               ('a key_ * 'b) list ->
               [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist_report_all_dups :
              ('a key_,
               ('a key_ * 'b) list ->
               [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val create_mapped :
              ('a key_,
               get_key:('r -> 'a key_) ->
               get_data:('r -> 'b) ->
               'r list ->
               [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val create_with_key :
              ('a key_,
               get_key:('r -> 'a key_) ->
               'r list ->
               [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val group :
              ('a key_,
               get_key:('r -> 'a key_) ->
               get_data:('r -> 'b) ->
               combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
              Core_kernel.Core_hashtbl_intf.create_options_without_hashable
            val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
            val clear : ('a, 'b) t_ -> unit
            val copy : ('a, 'b) t_ -> ('a, 'b) t_
            val invariant : ('a, 'b) t_ -> unit
            val fold :
              ('a, 'b) t_ ->
              init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
            val iter :
              ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
            val existsi :
              ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
            val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
            val length : ('a, 'b) t_ -> int
            val is_empty : ('a, 'b) t_ -> bool
            val mem : ('a, 'b) t_ -> 'a key_ -> bool
            val remove : ('a, 'b) t_ -> 'a key_ -> unit
            val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
            val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
            val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
            val add :
              ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
            val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
            val change :
              ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
            val add_multi :
              ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
            val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
            val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
            val mapi :
              ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
            val filter_map :
              ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
            val filter_mapi :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
            val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
            val filteri :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
            val partition_map :
              ('a, 'b) t_ ->
              f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
              ('a, 'c) t_ * ('a, 'd) t_
            val partition_mapi :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
              ('a, 'c) t_ * ('a, 'd) t_
            val partition_tf :
              ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
            val partitioni_tf :
              ('a, 'b) t_ ->
              f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
            val find_or_add :
              ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
            val find : ('a, 'b) t_ -> 'a key_ -> 'b option
            val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
            val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
            val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
            val merge :
              ('k, 'a) t_ ->
              ('k, 'b) t_ ->
              f:(key:'k key_ ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              ('k, 'c) t_
            val merge_into :
              f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
              src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
            val keys : ('a, 'b) t_ -> 'a key_ list
            val data : ('a, 'b) t_ -> 'b list
            val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
            val filteri_inplace :
              ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
            val equal :
              ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
            val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
            val validate :
              name:('a key_ -> string) ->
              'b Core_kernel.Validate.check ->
              ('a, 'b) t_ Core_kernel.Validate.check
            val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
            val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
            val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
            val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
            val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
            val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
            val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_read_t__ :
              ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
            val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
          end
      val sexp_of_t :
        ('a -> Sexplib.Sexp.t) ->
        ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
    end
  module Int :
    sig
      type t = int
      val of_float : float -> t
      val to_float : t -> float
      val of_int_exn : int -> t
      val to_int_exn : t -> int
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Core_int.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Core_int.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      val to_string_hum : ?delimiter:char -> t -> string
      val num_bits : int
      val zero : t
      val one : t
      val minus_one : t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val neg : t -> t
      val succ : t -> t
      val pred : t -> t
      val abs : t -> t
      val rem : t -> t -> t
      val max_value : t
      val min_value : t
      val bit_and : t -> t -> t
      val bit_or : t -> t -> t
      val bit_xor : t -> t -> t
      val bit_not : t -> t
      val decr : t ref -> unit
      val incr : t ref -> unit
      val shift_left : t -> int -> t
      val shift_right : t -> int -> t
      val shift_right_logical : t -> int -> t
      val of_int32_exn : int32 -> t
      val to_int32_exn : t -> int32
      val to_int64 : t -> int64
      val of_nativeint_exn : nativeint -> t
      val to_nativeint_exn : t -> nativeint
      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
      val of_int : int -> t
      val to_int : t -> int
      val of_int32 : int32 -> t option
      val to_int32 : t -> int32 option
      val of_int64 : int64 -> t option
      val of_int64_exn : int64 -> t
      val of_nativeint : nativeint -> t option
      val to_nativeint : t -> nativeint
      val ceil_pow2 : int -> int
      val floor_pow2 : int -> int
      val is_pow2 : int -> bool
      module Infix :
        sig
          val ( % ) : t -> t -> t
          val ( /% ) : t -> t -> t
          val ( // ) : int -> int -> float
        end
    end
  val ( % ) : Int.t -> Int.t -> Int.t
  val ( /% ) : Int.t -> Int.t -> Int.t
  val ( // ) : int -> int -> float
  module In_channel :
    sig
      type t = in_channel
      val stdin : t
      val create : ?binary:bool -> string -> t
      val with_file : ?binary:bool -> string -> f:(t -> 'a) -> 'a
      val close : t -> unit
      val input : t -> buf:string -> pos:int -> len:int -> int
      val really_input : t -> buf:string -> pos:int -> len:int -> unit option
      val input_byte : t -> int option
      val input_char : t -> char option
      val input_binary_int : t -> int option
      val unsafe_input_value : t -> 'a option
      val input_all : t -> string
      val input_line : ?fix_win_eol:bool -> t -> string option
      val fold_lines :
        ?fix_win_eol:bool -> t -> init:'a -> f:('a -> string -> 'a) -> 'a
      val input_lines : ?fix_win_eol:bool -> t -> string list
      val iter_lines : ?fix_win_eol:bool -> t -> f:(string -> unit) -> unit
      val seek : t -> int64 -> unit
      val pos : t -> int64
      val length : t -> int64
      val set_binary_mode : t -> bool -> unit
      val read_lines : string -> string list
      val read_all : string -> string
    end
  module Int32 :
    sig
      type t = int32
      val of_float : float -> t
      val to_float : t -> float
      val of_int_exn : int -> t
      val to_int_exn : t -> int
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Core_int32.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Core_int32.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      val to_string_hum : ?delimiter:char -> t -> string
      val num_bits : int
      val zero : t
      val one : t
      val minus_one : t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val neg : t -> t
      val succ : t -> t
      val pred : t -> t
      val abs : t -> t
      val rem : t -> t -> t
      val max_value : t
      val min_value : t
      val bit_and : t -> t -> t
      val bit_or : t -> t -> t
      val bit_xor : t -> t -> t
      val bit_not : t -> t
      val decr : t ref -> unit
      val incr : t ref -> unit
      val shift_left : t -> int -> t
      val shift_right : t -> int -> t
      val shift_right_logical : t -> int -> t
      val of_int32_exn : int32 -> t
      val to_int32_exn : t -> int32
      val of_int64_exn : int64 -> t
      val to_int64 : t -> int64
      val of_nativeint_exn : nativeint -> t
      val to_nativeint_exn : t -> nativeint
      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
      val bits_of_float : float -> t
      val float_of_bits : t -> float
      val of_int : int -> t option
      val to_int : t -> int option
      val of_int32 : int32 -> t
      val to_int32 : t -> int32
      val of_int64 : int64 -> t option
      val of_nativeint : nativeint -> t option
      val to_nativeint : t -> nativeint
    end
  module Int63 :
    sig
      type t = Core_kernel.Core_int63.t
      val of_float : float -> t
      val to_float : t -> float
      val of_int_exn : int -> t
      val to_int_exn : t -> int
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Core_int63.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Core_int63.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      val to_string_hum : ?delimiter:char -> t -> string
      val num_bits : int
      val zero : t
      val one : t
      val minus_one : t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val neg : t -> t
      val succ : t -> t
      val pred : t -> t
      val abs : t -> t
      val rem : t -> t -> t
      val max_value : t
      val min_value : t
      val bit_and : t -> t -> t
      val bit_or : t -> t -> t
      val bit_xor : t -> t -> t
      val bit_not : t -> t
      val decr : t ref -> unit
      val incr : t ref -> unit
      val shift_left : t -> int -> t
      val shift_right : t -> int -> t
      val shift_right_logical : t -> int -> t
      val of_int32_exn : int32 -> t
      val to_int32_exn : t -> int32
      val of_int64_exn : int64 -> t
      val to_int64 : t -> int64
      val of_nativeint_exn : nativeint -> t
      val to_nativeint_exn : t -> nativeint
      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
      val of_int : int -> t
      val to_int : t -> int option
    end
  module Int64 :
    sig
      type t = int64
      val of_int_exn : int -> t
      val to_int_exn : t -> int
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Core_int64.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Core_int64.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      val to_string_hum : ?delimiter:char -> t -> string
      val num_bits : int
      val zero : t
      val one : t
      val minus_one : t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val neg : t -> t
      val succ : t -> t
      val pred : t -> t
      val abs : t -> t
      val rem : t -> t -> t
      val max_value : t
      val min_value : t
      val bit_and : t -> t -> t
      val bit_or : t -> t -> t
      val bit_xor : t -> t -> t
      val bit_not : t -> t
      val decr : t ref -> unit
      val incr : t ref -> unit
      val shift_left : t -> int -> t
      val shift_right : t -> int -> t
      val shift_right_logical : t -> int -> t
      val of_int32_exn : int32 -> t
      val to_int32_exn : t -> int32
      val of_int64_exn : int64 -> t
      val to_int64 : t -> int64
      val of_nativeint_exn : nativeint -> t
      val to_nativeint_exn : t -> nativeint
      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
      val of_int : int -> t
      val to_int : t -> int option
      val of_float : float -> t
      val to_float : t -> float
      val of_int32 : int32 -> t
      val of_nativeint : nativeint -> t
      val bits_of_float : float -> t
      val float_of_bits : t -> float
      val to_int32 : t -> int32 option
      val to_nativeint : t -> nativeint option
      val of_int64 : t -> t
    end
  module Interfaces :
    sig
      module type Binable = Core_kernel.Binable0.S
      module type Comparable = Core_kernel.Comparable.S
      module type Comparable_binable = Core_kernel.Comparable.S_binable
      module type Floatable = Core_kernel.Floatable.S
      module type Hashable = Core_kernel.Hashable.S
      module type Hashable_binable = Core_kernel.Hashable.S_binable
      module type Identifiable = Core_kernel.Identifiable.S
      module type Infix_comparators = Core_kernel.Comparable.Infix
      module type Intable = Core_kernel.Intable.S
      module type Monad = Core_kernel.Monad.S
      module type Robustly_comparable = Core_kernel.Robustly_comparable.S
      module type Sexpable = Core_kernel.Sexpable.S
      module type Stringable = Core_kernel.Stringable.S
      module type Unit = sig  end
    end
  module type Binable = Core_kernel.Binable0.S
  module type Comparable = Core_kernel.Comparable.S
  module type Comparable_binable = Core_kernel.Comparable.S_binable
  module type Floatable = Core_kernel.Floatable.S
  module type Hashable = Core_kernel.Hashable.S
  module type Hashable_binable = Core_kernel.Hashable.S_binable
  module type Identifiable = Core_kernel.Identifiable.S
  module type Infix_comparators = Core_kernel.Comparable.Infix
  module type Intable = Core_kernel.Intable.S
  module type Monad = Core_kernel.Monad.S
  module type Robustly_comparable = Core_kernel.Robustly_comparable.S
  module type Sexpable = Core_kernel.Sexpable.S
  module type Stringable = Core_kernel.Stringable.S
  module type Unit = sig  end
  module Interval :
    sig
      module type S1 = Core.Interval_intf.S1
      type 'a t = 'a Core.Interval.t
      type 'a bound_ = 'a
      val create : 'a bound_ -> 'a bound_ -> 'a t
      val empty : 'a t
      val intersect : 'a t -> 'a t -> 'a t
      val is_empty : 'a t -> bool
      val is_empty_or_singleton : 'a t -> bool
      val bounds : 'a t -> ('a bound_ * 'a bound_) option
      val lbound : 'a t -> 'a bound_ option
      val ubound : 'a t -> 'a bound_ option
      val bounds_exn : 'a t -> 'a bound_ * 'a bound_
      val lbound_exn : 'a t -> 'a bound_
      val ubound_exn : 'a t -> 'a bound_
      val contains : 'a t -> 'a bound_ -> bool
      val compare_value :
        'a t ->
        'a bound_ -> [ `Above | `Below | `Interval_is_empty | `Within ]
      val bound : 'a t -> 'a bound_ -> 'a bound_ option
      val is_superset : 'a t -> of_:'a t -> bool
      val is_subset : 'a t -> of_:'a t -> bool
      val map : 'a t -> f:('a bound_ -> 'b bound_) -> 'b t
      val are_disjoint : 'a t list -> bool
      val are_disjoint_as_open_intervals : 'a t list -> bool
      val list_intersect : 'a t list -> 'a t list -> 'a t list
      val half_open_intervals_are_a_partition : 'a t list -> bool
      module Set :
        sig
          type 'a t = 'a Core.Interval.Set.t
          val create : ('a bound_ * 'a bound_) list -> 'a t
          val create_from_intervals : 'a t list -> 'a t
          val contains : 'a t -> 'a bound_ -> bool
          val contains_set : container:'a t -> contained:'a t -> bool
          val ubound_exn : 'a t -> 'a bound_
          val lbound_exn : 'a t -> 'a bound_
          val ubound : 'a t -> 'a bound_ option
          val lbound : 'a t -> 'a bound_ option
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
          val bin_read_t :
            'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
          val bin_read_t_ :
            'a Bin_prot.Unsafe_read_c.reader ->
            'a t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            'a Bin_prot.Unsafe_read_c.reader ->
            (int -> 'a t) Bin_prot.Unsafe_read_c.reader
          val bin_reader_t :
            'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
          val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
          val bin_write_t :
            'a Bin_prot.Unsafe_write_c.writer ->
            'a t Bin_prot.Write_ml.writer
          val bin_write_t_ :
            'a Bin_prot.Unsafe_write_c.writer ->
            'a t Bin_prot.Unsafe_write_c.writer
          val bin_writer_t :
            'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
        end
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
      module type S =
        sig
          type t
          type bound
          type 'a t_ = t
          type 'a bound_ = bound
          val empty : 'a t_
          val intersect : 'a t_ -> 'a t_ -> 'a t_
          val is_empty : 'a t_ -> bool
          val is_empty_or_singleton : 'a t_ -> bool
          val bounds : 'a t_ -> ('a bound_ * 'a bound_) option
          val lbound : 'a t_ -> 'a bound_ option
          val ubound : 'a t_ -> 'a bound_ option
          val bounds_exn : 'a t_ -> 'a bound_ * 'a bound_
          val lbound_exn : 'a t_ -> 'a bound_
          val ubound_exn : 'a t_ -> 'a bound_
          val contains : 'a t_ -> 'a bound_ -> bool
          val compare_value :
            'a t_ ->
            'a bound_ -> [ `Above | `Below | `Interval_is_empty | `Within ]
          val bound : 'a t_ -> 'a bound_ -> 'a bound_ option
          val is_superset : 'a t_ -> of_:'a t_ -> bool
          val is_subset : 'a t_ -> of_:'a t_ -> bool
          val map : 'a t_ -> f:('a bound_ -> 'b bound_) -> 'b t_
          val are_disjoint : 'a t_ list -> bool
          val are_disjoint_as_open_intervals : 'a t_ list -> bool
          val list_intersect : 'a t_ list -> 'a t_ list -> 'a t_ list
          val half_open_intervals_are_a_partition : 'a t_ list -> bool
          val create : bound -> bound -> t
          val to_poly : t -> bound t
          module Set :
            sig
              type t
              type 'a t_ = t
              val create : ('a bound_ * 'a bound_) list -> 'a t_
              val create_from_intervals : 'a t_ list -> 'a t_
              val contains : 'a t_ -> 'a bound_ -> bool
              val contains_set : container:'a t_ -> contained:'a t_ -> bool
              val ubound_exn : 'a t_ -> 'a bound_
              val lbound_exn : 'a t_ -> 'a bound_
              val ubound : 'a t_ -> 'a bound_ option
              val lbound : 'a t_ -> 'a bound_ option
              val to_poly : t -> bound Set.t
              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
          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
      module Make :
        functor
          (Bound : sig
                     type t
                     val ( >= ) : t -> t -> bool
                     val ( <= ) : t -> t -> bool
                     val ( = ) : t -> t -> bool
                     val ( > ) : t -> t -> bool
                     val ( < ) : t -> t -> bool
                     val ( <> ) : t -> t -> bool
                     val equal : t -> t -> bool
                     val compare : t -> t -> int
                     val min : t -> t -> t
                     val max : t -> t -> t
                     val ascending : t -> t -> int
                     val descending : t -> t -> int
                     val between : t -> low:t -> high:t -> bool
                     module Replace_polymorphic_compare :
                       sig
                         val ( >= ) : t -> t -> bool
                         val ( <= ) : t -> t -> bool
                         val ( = ) : t -> t -> bool
                         val ( > ) : t -> t -> bool
                         val ( < ) : t -> t -> bool
                         val ( <> ) : t -> t -> bool
                         val equal : t -> t -> bool
                         val compare : t -> t -> int
                         val min : t -> t -> t
                         val max : t -> t -> t
                         val _squelch_unused_module_warning_ : unit
                       end
                     type comparator
                     val comparator :
                       (t, comparator) Core_kernel.Comparator.t
                     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
                             val compare : t -> t -> int
                             val t_of_sexp : Sexplib.Sexp.t -> t
                             val sexp_of_t : t -> Sexplib.Sexp.t
                             type comparator = comparator
                             val comparator :
                               (t, comparator) Core_kernel.Comparator.t_
                           end
                         module Tree :
                           sig
                             type 'a t =
                                 (Key.t, 'a, Key.comparator)
                                 Core_kernel.Core_map.Tree.t
                             val empty : 'a t
                             val singleton : Key.t -> 'a -> 'a t
                             val of_alist :
                               (Key.t * 'a) list ->
                               [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                             val add_multi :
                               'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                             val iter2 :
                               'a t ->
                               'b t ->
                               f:(key:Key.t ->
                                  data:[ `Both of 'a * 'b
                                       | `Left of 'a
                                       | `Right of 'b ] ->
                                  unit) ->
                               unit
                             val map : 'a t -> f:('a -> 'b) -> 'b t
                             val mapi :
                               'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                             val fold :
                               'a t ->
                               init:'b ->
                               f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                             val fold_right :
                               'a t ->
                               init:'b ->
                               f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                             val filter :
                               'a t ->
                               f:(key:Key.t -> data:'a -> bool) -> 'a t
                             val filter_map :
                               'a t -> f:('a -> 'b option) -> 'b t
                             val filter_mapi :
                               'a t ->
                               f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                             val compare_direct :
                               ('a -> 'a -> int) -> 'a t -> 'a t -> int
                             val equal :
                               ('a -> 'a -> 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) ->
                               'a Core_kernel.Validate.check ->
                               'a t Core_kernel.Validate.check
                             val merge :
                               'a t ->
                               'b t ->
                               f:(key:Key.t ->
                                  [ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] -> 'c option) ->
                               'c t
                             val symmetric_diff :
                               'a t ->
                               'a t ->
                               data_equal:('a -> 'a -> bool) ->
                               (Key.t *
                                [ `Left of 'a
                                | `Right of 'a
                                | `Unequal of 'a * 'a ])
                               list
                             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:('a -> bool) -> bool
                             val exists : 'a t -> f:('a -> bool) -> bool
                             val fold_range_inclusive :
                               'a t ->
                               min:Key.t ->
                               max:Key.t ->
                               init:'b ->
                               f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                             val range_to_alist :
                               'a t ->
                               min:Key.t -> max:Key.t -> (Key.t * 'a) list
                             val prev_key :
                               'a t -> Key.t -> (Key.t * 'a) option
                             val next_key :
                               'a t -> Key.t -> (Key.t * 'a) option
                             val rank : 'a t -> Key.t -> int option
                             val to_tree : 'a t -> 'a t
                             val t_of_sexp :
                               (Sexplib.Sexp.t -> 'a) ->
                               Sexplib.Sexp.t -> 'a t
                             val sexp_of_t :
                               ('a -> Sexplib.Sexp.t) ->
                               'a t -> Sexplib.Sexp.t
                           end
                         type 'a t =
                             (Key.t, 'a, Key.comparator)
                             Core_kernel.Core_map.t
                         val empty : 'a t
                         val singleton : Key.t -> 'a -> 'a t
                         val of_alist :
                           (Key.t * 'a) list ->
                           [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
                         val add_multi :
                           'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                         val iter2 :
                           'a t ->
                           'b t ->
                           f:(key:Key.t ->
                              data:[ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] ->
                              unit) ->
                           unit
                         val map : 'a t -> f:('a -> 'b) -> 'b t
                         val mapi :
                           'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                         val fold :
                           'a t ->
                           init:'b ->
                           f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                         val fold_right :
                           'a t ->
                           init:'b ->
                           f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                         val filter :
                           'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                         val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                         val filter_mapi :
                           'a t ->
                           f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                         val compare_direct :
                           ('a -> 'a -> int) -> 'a t -> 'a t -> int
                         val equal :
                           ('a -> 'a -> 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) ->
                           'a Core_kernel.Validate.check ->
                           'a t Core_kernel.Validate.check
                         val merge :
                           'a t ->
                           'b t ->
                           f:(key:Key.t ->
                              [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                              'c option) ->
                           'c t
                         val symmetric_diff :
                           'a t ->
                           'a t ->
                           data_equal:('a -> 'a -> bool) ->
                           (Key.t *
                            [ `Left of 'a
                            | `Right of 'a
                            | `Unequal of 'a * 'a ])
                           list
                         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:('a -> bool) -> bool
                         val exists : 'a t -> f:('a -> bool) -> bool
                         val fold_range_inclusive :
                           'a t ->
                           min:Key.t ->
                           max:Key.t ->
                           init:'b ->
                           f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                         val range_to_alist :
                           'a t ->
                           min:Key.t -> max:Key.t -> (Key.t * 'a) list
                         val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                         val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                         val rank : 'a t -> Key.t -> int option
                         val to_tree : 'a t -> 'a Tree.t
                         val t_of_sexp :
                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                         val sexp_of_t :
                           ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                         val compare :
                           ('a -> 'a -> int) -> 'a t -> 'a t -> int
                       end
                     module Set :
                       sig
                         module Elt :
                           sig
                             type t = t
                             val compare : t -> t -> int
                             val t_of_sexp : Sexplib.Sexp.t -> t
                             val sexp_of_t : t -> Sexplib.Sexp.t
                             type comparator = comparator
                             val comparator :
                               (t, comparator) Core_kernel.Comparator.t_
                           end
                         module Tree :
                           sig
                             type t =
                                 (Elt.t, Elt.comparator)
                                 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 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 compare_direct : t -> t -> int
                             val equal : t -> t -> bool
                             val subset : t -> t -> bool
                             val fold_until :
                               t ->
                               init:'b ->
                               f:('b ->
                                  Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
                               'b
                             val fold_right :
                               t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
                             val filter_map :
                               ('a, 'b) Core_kernel.Core_set.Tree.t ->
                               f:('a -> Elt.t option) -> t
                             val of_tree : 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) 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 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 compare_direct : t -> t -> int
                         val equal : t -> t -> bool
                         val subset : t -> t -> bool
                         val fold_until :
                           t ->
                           init:'b ->
                           f:('b ->
                              Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
                           'b
                         val fold_right :
                           t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
                         val filter_map :
                           ('a, 'b) Core_kernel.Core_set.t ->
                           f:('a -> Elt.t option) -> t
                         val of_tree : Tree.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 Core_kernel.Std.Bin_prot.Type_class.t
                     val bin_read_t :
                       t Core_kernel.Std.Bin_prot.Read_ml.reader
                     val bin_read_t_ :
                       t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                     val bin_read_t__ :
                       (int -> t)
                       Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                     val bin_reader_t :
                       t Core_kernel.Std.Bin_prot.Type_class.reader
                     val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                     val bin_write_t :
                       t Core_kernel.Std.Bin_prot.Write_ml.writer
                     val bin_write_t_ :
                       t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                     val bin_writer_t :
                       t Core_kernel.Std.Bin_prot.Type_class.writer
                   end) ->
          sig
            type t = Core.Interval.Make(Bound).t
            type bound = Bound.t
            type 'a t_ = t
            type 'a bound_ = bound
            val empty : 'a t_
            val intersect : 'a t_ -> 'a t_ -> 'a t_
            val is_empty : 'a t_ -> bool
            val is_empty_or_singleton : 'a t_ -> bool
            val bounds : 'a t_ -> ('a bound_ * 'a bound_) option
            val lbound : 'a t_ -> 'a bound_ option
            val ubound : 'a t_ -> 'a bound_ option
            val bounds_exn : 'a t_ -> 'a bound_ * 'a bound_
            val lbound_exn : 'a t_ -> 'a bound_
            val ubound_exn : 'a t_ -> 'a bound_
            val contains : 'a t_ -> 'a bound_ -> bool
            val compare_value :
              'a t_ ->
              'a bound_ -> [ `Above | `Below | `Interval_is_empty | `Within ]
            val bound : 'a t_ -> 'a bound_ -> 'a bound_ option
            val is_superset : 'a t_ -> of_:'a t_ -> bool
            val is_subset : 'a t_ -> of_:'a t_ -> bool
            val map : 'a t_ -> f:('a bound_ -> 'b bound_) -> 'b t_
            val are_disjoint : 'a t_ list -> bool
            val are_disjoint_as_open_intervals : 'a t_ list -> bool
            val list_intersect : 'a t_ list -> 'a t_ list -> 'a t_ list
            val half_open_intervals_are_a_partition : 'a t_ list -> bool
            val create : bound -> bound -> t
            val to_poly : t -> bound t
            module Set :
              sig
                type t = Core.Interval.Make(Bound).Set.t
                type 'a t_ = t
                val create : ('a bound_ * 'a bound_) list -> 'a t_
                val create_from_intervals : 'a t_ list -> 'a t_
                val contains : 'a t_ -> 'a bound_ -> bool
                val contains_set : container:'a t_ -> contained:'a t_ -> bool
                val ubound_exn : 'a t_ -> 'a bound_
                val lbound_exn : 'a t_ -> 'a bound_
                val ubound : 'a t_ -> 'a bound_ option
                val lbound : 'a t_ -> 'a bound_ option
                val to_poly : t -> bound Set.t
                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
            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
      module Float :
        sig
          type t = Core.Interval.Float.t
          type bound = Core_kernel.Std.Float.t
          type 'a t_ = t
          type 'a bound_ = bound
          val empty : 'a t_
          val intersect : 'a t_ -> 'a t_ -> 'a t_
          val is_empty : 'a t_ -> bool
          val is_empty_or_singleton : 'a t_ -> bool
          val bounds : 'a t_ -> ('a bound_ * 'a bound_) option
          val lbound : 'a t_ -> 'a bound_ option
          val ubound : 'a t_ -> 'a bound_ option
          val bounds_exn : 'a t_ -> 'a bound_ * 'a bound_
          val lbound_exn : 'a t_ -> 'a bound_
          val ubound_exn : 'a t_ -> 'a bound_
          val contains : 'a t_ -> 'a bound_ -> bool
          val compare_value :
            'a t_ ->
            'a bound_ -> [ `Above | `Below | `Interval_is_empty | `Within ]
          val bound : 'a t_ -> 'a bound_ -> 'a bound_ option
          val is_superset : 'a t_ -> of_:'a t_ -> bool
          val is_subset : 'a t_ -> of_:'a t_ -> bool
          val map : 'a t_ -> f:('a bound_ -> 'b bound_) -> 'b t_
          val are_disjoint : 'a t_ list -> bool
          val are_disjoint_as_open_intervals : 'a t_ list -> bool
          val list_intersect : 'a t_ list -> 'a t_ list -> 'a t_ list
          val half_open_intervals_are_a_partition : 'a t_ list -> bool
          val create : bound -> bound -> t
          val to_poly : t -> bound t
          module Set :
            sig
              type t = Core.Interval.Float.Set.t
              type 'a t_ = t
              val create : ('a bound_ * 'a bound_) list -> 'a t_
              val create_from_intervals : 'a t_ list -> 'a t_
              val contains : 'a t_ -> 'a bound_ -> bool
              val contains_set : container:'a t_ -> contained:'a t_ -> bool
              val ubound_exn : 'a t_ -> 'a bound_
              val lbound_exn : 'a t_ -> 'a bound_
              val ubound : 'a t_ -> 'a bound_ option
              val lbound : 'a t_ -> 'a bound_ option
              val to_poly : t -> bound Set.t
              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
          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
      module Int :
        sig
          type t = Core.Interval.Int.t
          type bound = Core_kernel.Std.Int.t
          type 'a t_ = t
          type 'a bound_ = bound
          val empty : 'a t_
          val intersect : 'a t_ -> 'a t_ -> 'a t_
          val is_empty : 'a t_ -> bool
          val is_empty_or_singleton : 'a t_ -> bool
          val bounds : 'a t_ -> ('a bound_ * 'a bound_) option
          val lbound : 'a t_ -> 'a bound_ option
          val ubound : 'a t_ -> 'a bound_ option
          val bounds_exn : 'a t_ -> 'a bound_ * 'a bound_
          val lbound_exn : 'a t_ -> 'a bound_
          val ubound_exn : 'a t_ -> 'a bound_
          val contains : 'a t_ -> 'a bound_ -> bool
          val compare_value :
            'a t_ ->
            'a bound_ -> [ `Above | `Below | `Interval_is_empty | `Within ]
          val bound : 'a t_ -> 'a bound_ -> 'a bound_ option
          val is_superset : 'a t_ -> of_:'a t_ -> bool
          val is_subset : 'a t_ -> of_:'a t_ -> bool
          val map : 'a t_ -> f:('a bound_ -> 'b bound_) -> 'b t_
          val are_disjoint : 'a t_ list -> bool
          val are_disjoint_as_open_intervals : 'a t_ list -> bool
          val list_intersect : 'a t_ list -> 'a t_ list -> 'a t_ list
          val half_open_intervals_are_a_partition : 'a t_ list -> bool
          val create : bound -> bound -> t
          val to_poly : t -> bound t
          module Set :
            sig
              type t = Core.Interval.Int.Set.t
              type 'a t_ = t
              val create : ('a bound_ * 'a bound_) list -> 'a t_
              val create_from_intervals : 'a t_ list -> 'a t_
              val contains : 'a t_ -> 'a bound_ -> bool
              val contains_set : container:'a t_ -> contained:'a t_ -> bool
              val ubound_exn : 'a t_ -> 'a bound_
              val lbound_exn : 'a t_ -> 'a bound_
              val ubound : 'a t_ -> 'a bound_ option
              val lbound : 'a t_ -> 'a bound_ option
              val to_poly : t -> bound Set.t
              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
          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
      module Time :
        sig
          type t = Core.Interval.Time.t
          type bound = Core.Time.t
          type 'a t_ = t
          type 'a bound_ = bound
          val empty : 'a t_
          val intersect : 'a t_ -> 'a t_ -> 'a t_
          val is_empty : 'a t_ -> bool
          val is_empty_or_singleton : 'a t_ -> bool
          val bounds : 'a t_ -> ('a bound_ * 'a bound_) option
          val lbound : 'a t_ -> 'a bound_ option
          val ubound : 'a t_ -> 'a bound_ option
          val bounds_exn : 'a t_ -> 'a bound_ * 'a bound_
          val lbound_exn : 'a t_ -> 'a bound_
          val ubound_exn : 'a t_ -> 'a bound_
          val contains : 'a t_ -> 'a bound_ -> bool
          val compare_value :
            'a t_ ->
            'a bound_ -> [ `Above | `Below | `Interval_is_empty | `Within ]
          val bound : 'a t_ -> 'a bound_ -> 'a bound_ option
          val is_superset : 'a t_ -> of_:'a t_ -> bool
          val is_subset : 'a t_ -> of_:'a t_ -> bool
          val map : 'a t_ -> f:('a bound_ -> 'b bound_) -> 'b t_
          val are_disjoint : 'a t_ list -> bool
          val are_disjoint_as_open_intervals : 'a t_ list -> bool
          val list_intersect : 'a t_ list -> 'a t_ list -> 'a t_ list
          val half_open_intervals_are_a_partition : 'a t_ list -> bool
          val create : bound -> bound -> t
          val to_poly : t -> bound t
          module Set :
            sig
              type t = Core.Interval.Time.Set.t
              type 'a t_ = t
              val create : ('a bound_ * 'a bound_) list -> 'a t_
              val create_from_intervals : 'a t_ list -> 'a t_
              val contains : 'a t_ -> 'a bound_ -> bool
              val contains_set : container:'a t_ -> contained:'a t_ -> bool
              val ubound_exn : 'a t_ -> 'a bound_
              val lbound_exn : 'a t_ -> 'a bound_
              val ubound : 'a t_ -> 'a bound_ option
              val lbound : 'a t_ -> 'a bound_ option
              val to_poly : t -> bound Set.t
              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
          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
          val create_ending_after :
            ?zone:Core.Zone.t ->
            Core.Ofday.t * Core.Ofday.t -> now:Core.Time.t -> t
          val create_ending_before :
            ?zone:Core.Zone.t ->
            Core.Ofday.t * Core.Ofday.t -> ubound:Core.Time.t -> t
        end
      module Ofday :
        sig
          type t = Core.Interval.Ofday.t
          type bound = Core.Ofday.t
          type 'a t_ = t
          type 'a bound_ = bound
          val empty : 'a t_
          val intersect : 'a t_ -> 'a t_ -> 'a t_
          val is_empty : 'a t_ -> bool
          val is_empty_or_singleton : 'a t_ -> bool
          val bounds : 'a t_ -> ('a bound_ * 'a bound_) option
          val lbound : 'a t_ -> 'a bound_ option
          val ubound : 'a t_ -> 'a bound_ option
          val bounds_exn : 'a t_ -> 'a bound_ * 'a bound_
          val lbound_exn : 'a t_ -> 'a bound_
          val ubound_exn : 'a t_ -> 'a bound_
          val contains : 'a t_ -> 'a bound_ -> bool
          val compare_value :
            'a t_ ->
            'a bound_ -> [ `Above | `Below | `Interval_is_empty | `Within ]
          val bound : 'a t_ -> 'a bound_ -> 'a bound_ option
          val is_superset : 'a t_ -> of_:'a t_ -> bool
          val is_subset : 'a t_ -> of_:'a t_ -> bool
          val map : 'a t_ -> f:('a bound_ -> 'b bound_) -> 'b t_
          val are_disjoint : 'a t_ list -> bool
          val are_disjoint_as_open_intervals : 'a t_ list -> bool
          val list_intersect : 'a t_ list -> 'a t_ list -> 'a t_ list
          val half_open_intervals_are_a_partition : 'a t_ list -> bool
          val create : bound -> bound -> t
          val to_poly : t -> bound t
          module Set :
            sig
              type t = Core.Interval.Ofday.Set.t
              type 'a t_ = t
              val create : ('a bound_ * 'a bound_) list -> 'a t_
              val create_from_intervals : 'a t_ list -> 'a t_
              val contains : 'a t_ -> 'a bound_ -> bool
              val contains_set : container:'a t_ -> contained:'a t_ -> bool
              val ubound_exn : 'a t_ -> 'a bound_
              val lbound_exn : 'a t_ -> 'a bound_
              val ubound : 'a t_ -> 'a bound_ option
              val lbound : 'a t_ -> 'a bound_ option
              val to_poly : t -> bound Set.t
              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
          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
      module Stable :
        sig
          module V1 :
            sig
              module Float :
                sig
                  type t = Float.t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              module Int :
                sig
                  type t = Int.t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              module Time :
                sig
                  type t = Time.t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              module Ofday :
                sig
                  type t = Ofday.t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
            end
        end
    end
  module Lazy :
    sig
      type 'a t = 'a lazy_t
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      val bind : 'a t -> ('a -> 'b t) -> 'b t
      val return : 'a -> 'a t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      exception Undefined
      external force : 'a t -> 'a = "%lazy_force"
      val force_val : 'a t -> 'a
      val from_fun : (unit -> 'a) -> 'a t
      val from_val : 'a -> 'a t
      val is_val : 'a t -> bool
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
    end
  val ( @ ) : 'a List.t -> 'a List.t -> 'a List.t
  module Map :
    sig
      module Tree :
        sig
          type ('k, 'v, 'cmp) t = ('k, 'v, 'cmp) Core_kernel.Core_map.Tree.t
          val empty :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t
          val singleton :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            'a -> 'b -> ('a, 'b, 'cmp) t
          val of_alist :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a * 'b) list ->
            [ `Duplicate_key of 'a | `Ok of ('a, 'b, 'cmp) t ]
          val of_alist_exn :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a * 'b) list -> ('a, 'b, 'cmp) t
          val of_alist_multi :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a * 'b) list -> ('a, 'b list, 'cmp) t
          val of_alist_fold :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a * 'b) list ->
            init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c, 'cmp) t
          val of_sorted_array :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a * 'b) array -> ('a, 'b, 'cmp) t Core_kernel.Or_error.t
          val of_sorted_array_unchecked :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a * 'b) array -> ('a, 'b, 'cmp) t
          val of_tree :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t
          val invariants :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> bool
          val is_empty : ('a, 'b, 'cmp) t -> bool
          val length : ('a, 'b, 'cmp) t -> int
          val add :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t
          val add_multi :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b list, 'cmp) t ->
            key:'a -> data:'b -> ('a, 'b list, 'cmp) t
          val change :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t ->
            'a -> ('b option -> 'b option) -> ('a, 'b, 'cmp) t
          val find :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> 'a -> 'b option
          val find_exn :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> 'a -> 'b
          val remove :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> 'a -> ('a, 'b, 'cmp) t
          val mem :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> 'a -> bool
          val iter :
            ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> unit) -> unit
          val iter2 :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t ->
            ('a, 'c, 'cmp) t ->
            f:(key:'a ->
               data:[ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> unit) ->
            unit
          val map : ('a, 'b, 'cmp) t -> f:('b -> 'c) -> ('a, 'c, 'cmp) t
          val mapi :
            ('a, 'b, 'cmp) t ->
            f:(key:'a -> data:'b -> 'c) -> ('a, 'c, 'cmp) t
          val fold :
            ('a, 'b, 'd) t ->
            init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
          val fold_right :
            ('a, 'b, 'd) t ->
            init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
          val filter :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t ->
            f:(key:'a -> data:'b -> bool) -> ('a, 'b, 'cmp) t
          val filter_map :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> f:('b -> 'c option) -> ('a, 'c, 'cmp) t
          val filter_mapi :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t ->
            f:(key:'a -> data:'b -> 'c option) -> ('a, 'c, 'cmp) t
          val compare_direct :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('b -> 'b -> int) -> ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t -> int
          val equal :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('b -> 'b -> bool) ->
            ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t -> bool
          val keys : ('a, 'b, 'c) t -> 'a list
          val data : ('a, 'b, 'c) t -> 'b list
          val to_alist : ('a, 'b, 'c) t -> ('a * 'b) list
          val validate :
            name:('a -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b, 'c) t Core_kernel.Validate.check
          val merge :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t ->
            ('a, 'c, 'cmp) t ->
            f:(key:'a ->
               [ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> 'd option) ->
            ('a, 'd, 'cmp) t
          val symmetric_diff :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t ->
            ('a, 'b, 'cmp) t ->
            data_equal:('b -> 'b -> bool) ->
            ('a * [ `Left of 'b | `Right of 'b | `Unequal of 'b * 'b ]) list
          val min_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option
          val min_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b
          val max_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option
          val max_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b
          val for_all : ('a, 'b, 'cmp) t -> f:('b -> bool) -> bool
          val exists : ('a, 'b, 'cmp) t -> f:('b -> bool) -> bool
          val fold_range_inclusive :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t ->
            min:'a ->
            max:'a -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
          val range_to_alist :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> min:'a -> max:'a -> ('a * 'b) list
          val prev_key :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> 'a -> ('a * 'b) option
          val next_key :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> 'a -> ('a * 'b) option
          val rank :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'b, 'cmp) t -> 'a -> int option
          val to_tree : ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t
          val sexp_of_t :
            ('k -> Sexplib.Sexp.t) ->
            ('v -> Sexplib.Sexp.t) ->
            ('cmp -> Sexplib.Sexp.t) -> ('k, 'v, 'cmp) t -> Sexplib.Sexp.t
        end
      type ('key, 'value, 'cmp) t =
          ('key, 'value, 'cmp) Core_kernel.Core_map.t
      val invariants : ('a, 'b, 'c) t -> bool
      val comparator :
        ('a, 'b, 'cmp) t -> ('a, 'cmp) Core_kernel.Comparator.t
      val empty :
        comparator:('a, 'cmp) Core_kernel.Comparator.t -> ('a, 'b, 'cmp) t
      val singleton :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        'a -> 'b -> ('a, 'b, 'cmp) t
      val of_alist :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a * 'b) list -> [ `Duplicate_key of 'a | `Ok of ('a, 'b, 'cmp) t ]
      val of_alist_exn :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a * 'b) list -> ('a, 'b, 'cmp) t
      val of_alist_multi :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a * 'b) list -> ('a, 'b list, 'cmp) t
      val of_alist_fold :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c, 'cmp) t
      val to_tree : ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) Tree.t
      val of_tree :
        comparator:('k, 'cmp) Core_kernel.Comparator.t ->
        ('k, 'v, 'cmp) Tree.t -> ('k, 'v, 'cmp) t
      val of_sorted_array :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a * 'b) array -> ('a, 'b, 'cmp) t Core_kernel.Or_error.t
      val of_sorted_array_unchecked :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a * 'b) array -> ('a, 'b, 'cmp) t
      val is_empty : ('a, 'b, 'c) t -> bool
      val length : ('a, 'b, 'c) t -> int
      val add : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t
      val add_multi :
        ('k, 'v list, 'cmp) t -> key:'k -> data:'v -> ('k, 'v list, 'cmp) t
      val change :
        ('k, 'v, 'cmp) t ->
        'k -> ('v option -> 'v option) -> ('k, 'v, 'cmp) t
      val find : ('k, 'v, 'cmp) t -> 'k -> 'v option
      val find_exn : ('k, 'v, 'cmp) t -> 'k -> 'v
      val remove : ('k, 'v, 'cmp) t -> 'k -> ('k, 'v, 'cmp) t
      val mem : ('k, 'a, 'cmp) t -> 'k -> bool
      val iter : ('k, 'v, 'a) t -> f:(key:'k -> data:'v -> unit) -> unit
      val iter2 :
        ('k, 'v1, 'cmp) t ->
        ('k, 'v2, 'cmp) t ->
        f:(key:'k ->
           data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> unit) ->
        unit
      val map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) t
      val mapi :
        ('k, 'v1, 'cmp) t ->
        f:(key:'k -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) t
      val fold :
        ('k, 'v, 'b) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a
      val fold_right :
        ('k, 'v, 'b) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a
      val filter :
        ('k, 'v, 'cmp) t -> f:(key:'k -> data:'v -> bool) -> ('k, 'v, 'cmp) t
      val filter_map :
        ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t
      val filter_mapi :
        ('k, 'v1, 'cmp) t ->
        f:(key:'k -> data:'v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t
      val compare_direct :
        ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> int
      val equal :
        ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> bool
      val keys : ('k, 'a, 'b) t -> 'k list
      val data : ('a, 'v, 'b) t -> 'v list
      val to_alist : ('k, 'v, 'a) t -> ('k * 'v) list
      val validate :
        name:('k -> string) ->
        'v Core_kernel.Validate.check ->
        ('k, 'v, 'a) t Core_kernel.Validate.check
      val merge :
        ('k, 'v1, 'cmp) t ->
        ('k, 'v2, 'cmp) t ->
        f:(key:'k ->
           [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
           'v3 option) ->
        ('k, 'v3, 'cmp) t
      val symmetric_diff :
        ('k, 'v, 'cmp) t ->
        ('k, 'v, 'cmp) t ->
        data_equal:('v -> 'v -> bool) ->
        ('k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]) list
      val min_elt : ('k, 'v, 'a) t -> ('k * 'v) option
      val min_elt_exn : ('k, 'v, 'a) t -> 'k * 'v
      val max_elt : ('k, 'v, 'a) t -> ('k * 'v) option
      val max_elt_exn : ('k, 'v, 'a) t -> 'k * 'v
      val for_all : ('k, 'v, 'a) t -> f:('v -> bool) -> bool
      val exists : ('k, 'v, 'a) t -> f:('v -> bool) -> bool
      val fold_range_inclusive :
        ('k, 'v, 'cmp) t ->
        min:'k ->
        max:'k -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a
      val range_to_alist :
        ('k, 'v, 'cmp) t -> min:'k -> max:'k -> ('k * 'v) list
      val prev_key : ('k, 'v, 'cmp) t -> 'k -> ('k * 'v) option
      val next_key : ('k, 'v, 'cmp) t -> 'k -> ('k * 'v) option
      val rank : ('k, 'v, 'cmp) t -> 'k -> int option
      module Poly :
        sig
          type ('a, 'b, 'c) map = ('a, 'b, 'c) t
          module Tree :
            sig
              type ('k, 'v) t =
                  ('k, 'v, Core_kernel.Comparator.Poly.comparator) Tree.t
              val empty : ('a, 'b) t
              val singleton : 'a -> 'b -> ('a, 'b) t
              val of_alist :
                ('a * 'b) list ->
                [ `Duplicate_key of 'a | `Ok of ('a, 'b) t ]
              val of_alist_exn : ('a * 'b) list -> ('a, 'b) t
              val of_alist_multi : ('a * 'b) list -> ('a, 'b list) t
              val of_alist_fold :
                ('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c) t
              val of_sorted_array :
                ('a * 'b) array -> ('a, 'b) t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : ('a * 'b) array -> ('a, 'b) t
              val of_tree : ('a, 'b) t -> ('a, 'b) t
              val invariants : ('a, 'b) t -> bool
              val is_empty : ('a, 'b) t -> bool
              val length : ('a, 'b) t -> int
              val add : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t
              val add_multi :
                ('a, 'b list) t -> key:'a -> data:'b -> ('a, 'b list) t
              val change :
                ('a, 'b) t -> 'a -> ('b option -> 'b option) -> ('a, 'b) t
              val find : ('a, 'b) t -> 'a -> 'b option
              val find_exn : ('a, 'b) t -> 'a -> 'b
              val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
              val mem : ('a, 'b) t -> 'a -> bool
              val iter : ('a, 'b) t -> f:(key:'a -> data:'b -> unit) -> unit
              val iter2 :
                ('a, 'b) t ->
                ('a, 'c) t ->
                f:(key:'a ->
                   data:[ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] ->
                   unit) ->
                unit
              val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
              val mapi :
                ('a, 'b) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c) t
              val fold :
                ('a, 'b) t ->
                init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
              val fold_right :
                ('a, 'b) t ->
                init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
              val filter :
                ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b) t
              val filter_map :
                ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t
              val filter_mapi :
                ('a, 'b) t ->
                f:(key:'a -> data:'b -> 'c option) -> ('a, 'c) t
              val compare_direct :
                ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
              val equal :
                ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
              val keys : ('a, 'b) t -> 'a list
              val data : ('a, 'b) t -> 'b list
              val to_alist : ('a, 'b) t -> ('a * 'b) list
              val validate :
                name:('a -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t Core_kernel.Validate.check
              val merge :
                ('a, 'b) t ->
                ('a, 'c) t ->
                f:(key:'a ->
                   [ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] ->
                   'd option) ->
                ('a, 'd) t
              val symmetric_diff :
                ('a, 'b) t ->
                ('a, 'b) t ->
                data_equal:('b -> 'b -> bool) ->
                ('a * [ `Left of 'b | `Right of 'b | `Unequal of 'b * 'b ])
                list
              val min_elt : ('a, 'b) t -> ('a * 'b) option
              val min_elt_exn : ('a, 'b) t -> 'a * 'b
              val max_elt : ('a, 'b) t -> ('a * 'b) option
              val max_elt_exn : ('a, 'b) t -> 'a * 'b
              val for_all : ('a, 'b) t -> f:('b -> bool) -> bool
              val exists : ('a, 'b) t -> f:('b -> bool) -> bool
              val fold_range_inclusive :
                ('a, 'b) t ->
                min:'a ->
                max:'a -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
              val range_to_alist :
                ('a, 'b) t -> min:'a -> max:'a -> ('a * 'b) list
              val prev_key : ('a, 'b) t -> 'a -> ('a * 'b) option
              val next_key : ('a, 'b) t -> 'a -> ('a * 'b) option
              val rank : ('a, 'b) t -> 'a -> int option
              val to_tree : ('a, 'b) t -> ('a, 'b) t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'k) ->
                (Sexplib.Sexp.t -> 'v) -> Sexplib.Sexp.t -> ('k, 'v) t
              val sexp_of_t :
                ('k -> Sexplib.Sexp.t) ->
                ('v -> Sexplib.Sexp.t) -> ('k, 'v) t -> Sexplib.Sexp.t
            end
          type ('a, 'b) t =
              ('a, 'b, Core_kernel.Comparator.Poly.comparator) map
          val empty : ('a, 'b) t
          val singleton : 'a -> 'b -> ('a, 'b) t
          val of_alist :
            ('a * 'b) list -> [ `Duplicate_key of 'a | `Ok of ('a, 'b) t ]
          val of_alist_exn : ('a * 'b) list -> ('a, 'b) t
          val of_alist_multi : ('a * 'b) list -> ('a, 'b list) t
          val of_alist_fold :
            ('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c) t
          val of_sorted_array :
            ('a * 'b) array -> ('a, 'b) t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : ('a * 'b) array -> ('a, 'b) t
          val of_tree : ('a, 'b) Tree.t -> ('a, 'b) t
          val invariants : ('a, 'b) t -> bool
          val is_empty : ('a, 'b) t -> bool
          val length : ('a, 'b) t -> int
          val add : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t
          val add_multi :
            ('a, 'b list) t -> key:'a -> data:'b -> ('a, 'b list) t
          val change :
            ('a, 'b) t -> 'a -> ('b option -> 'b option) -> ('a, 'b) t
          val find : ('a, 'b) t -> 'a -> 'b option
          val find_exn : ('a, 'b) t -> 'a -> 'b
          val remove : ('a, 'b) t -> 'a -> ('a, 'b) t
          val mem : ('a, 'b) t -> 'a -> bool
          val iter : ('a, 'b) t -> f:(key:'a -> data:'b -> unit) -> unit
          val iter2 :
            ('a, 'b) t ->
            ('a, 'c) t ->
            f:(key:'a ->
               data:[ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> unit) ->
            unit
          val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
          val mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c) t
          val fold :
            ('a, 'b) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
          val fold_right :
            ('a, 'b) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
          val filter :
            ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b) t
          val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t
          val filter_mapi :
            ('a, 'b) t -> f:(key:'a -> data:'b -> 'c option) -> ('a, 'c) t
          val compare_direct :
            ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
          val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
          val keys : ('a, 'b) t -> 'a list
          val data : ('a, 'b) t -> 'b list
          val to_alist : ('a, 'b) t -> ('a * 'b) list
          val validate :
            name:('a -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t Core_kernel.Validate.check
          val merge :
            ('a, 'b) t ->
            ('a, 'c) t ->
            f:(key:'a ->
               [ `Both of 'b * 'c | `Left of 'b | `Right of 'c ] -> 'd option) ->
            ('a, 'd) t
          val symmetric_diff :
            ('a, 'b) t ->
            ('a, 'b) t ->
            data_equal:('b -> 'b -> bool) ->
            ('a * [ `Left of 'b | `Right of 'b | `Unequal of 'b * 'b ]) list
          val min_elt : ('a, 'b) t -> ('a * 'b) option
          val min_elt_exn : ('a, 'b) t -> 'a * 'b
          val max_elt : ('a, 'b) t -> ('a * 'b) option
          val max_elt_exn : ('a, 'b) t -> 'a * 'b
          val for_all : ('a, 'b) t -> f:('b -> bool) -> bool
          val exists : ('a, 'b) t -> f:('b -> bool) -> bool
          val fold_range_inclusive :
            ('a, 'b) t ->
            min:'a ->
            max:'a -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
          val range_to_alist :
            ('a, 'b) t -> min:'a -> max:'a -> ('a * 'b) list
          val prev_key : ('a, 'b) t -> 'a -> ('a * 'b) option
          val next_key : ('a, 'b) t -> 'a -> ('a * 'b) option
          val rank : ('a, 'b) t -> 'a -> int option
          val to_tree : ('a, 'b) t -> ('a, 'b) Tree.t
          val compare :
            ('a -> 'a -> int) ->
            ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'a) ->
            (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
          val bin_t :
            'a Bin_prot.Type_class.t ->
            'b Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
          val bin_read_t :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            ('a, 'b) t Bin_prot.Read_ml.reader
          val bin_read_t_ :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            ('a, 'b) t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            'a Bin_prot.Unsafe_read_c.reader ->
            'b Bin_prot.Unsafe_read_c.reader ->
            (int -> ('a, 'b) t) Bin_prot.Unsafe_read_c.reader
          val bin_reader_t :
            'a Bin_prot.Type_class.reader ->
            'b Bin_prot.Type_class.reader ->
            ('a, 'b) t Bin_prot.Type_class.reader
          val bin_size_t :
            'a Bin_prot.Size.sizer ->
            'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
          val bin_write_t :
            'a Bin_prot.Unsafe_write_c.writer ->
            'b Bin_prot.Unsafe_write_c.writer ->
            ('a, 'b) t Bin_prot.Write_ml.writer
          val bin_write_t_ :
            'a Bin_prot.Unsafe_write_c.writer ->
            'b Bin_prot.Unsafe_write_c.writer ->
            ('a, 'b) t Bin_prot.Unsafe_write_c.writer
          val bin_writer_t :
            'a Bin_prot.Type_class.writer ->
            'b Bin_prot.Type_class.writer ->
            ('a, 'b) t Bin_prot.Type_class.writer
        end
      module type Key = Core_kernel.Core_map_intf.Key
      module type Key_binable = Core_kernel.Core_map_intf.Key_binable
      module type S =
        sig
          module Key : Core_kernel.Comparator.S
          module Tree :
            sig
              type 'a t = (Key.t, 'a, Key.comparator) Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        end
      module type S_binable =
        sig
          module Key : Core_kernel.Comparator.S
          module Tree :
            sig
              type 'a t = (Key.t, 'a, Key.comparator) Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Make :
        functor (Key : Key) ->
          sig
            module Key :
              sig
                type t = Key.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator =
                    Core_kernel.Core_map.Make(Key).Key.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type 'a t = (Key.t, 'a, Key.comparator) Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> 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) ->
                  'a Core_kernel.Validate.check ->
                  'a t Core_kernel.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t *
                   [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                  list
                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:('a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val t_of_sexp :
                  (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              end
            type 'a t = (Key.t, 'a, Key.comparator) t
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> 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) ->
              'a Core_kernel.Validate.check ->
              'a t Core_kernel.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
              list
            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:('a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
            val next_key : 'a t -> Key.t -> (Key.t * 'a) option
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
            val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          end
      module Make_using_comparator :
        functor (Key : Core_kernel.Comparator.S) ->
          sig
            module Key :
              sig
                type t = Key.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator = Key.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type 'a t = (Key.t, 'a, Key.comparator) Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> 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) ->
                  'a Core_kernel.Validate.check ->
                  'a t Core_kernel.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t *
                   [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                  list
                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:('a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val t_of_sexp :
                  (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              end
            type 'a t = (Key.t, 'a, Key.comparator) t
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> 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) ->
              'a Core_kernel.Validate.check ->
              'a t Core_kernel.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
              list
            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:('a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
            val next_key : 'a t -> Key.t -> (Key.t * 'a) option
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
            val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          end
      module Make_binable :
        functor (Key : Key_binable) ->
          sig
            module Key :
              sig
                type t = Key.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator =
                    Core_kernel.Core_map.Make_binable(Key).Key.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type 'a t = (Key.t, 'a, Key.comparator) Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> 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) ->
                  'a Core_kernel.Validate.check ->
                  'a t Core_kernel.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t *
                   [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                  list
                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:('a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val t_of_sexp :
                  (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              end
            type 'a t = (Key.t, 'a, Key.comparator) t
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> 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) ->
              'a Core_kernel.Validate.check ->
              'a t Core_kernel.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
              list
            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:('a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
            val next_key : 'a t -> Key.t -> (Key.t * 'a) option
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
            val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
            val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
            val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
            val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
            val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_read_t__ :
              ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
            val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
          end
      module Make_binable_using_comparator :
        functor (Key : Core_kernel.Comparator.S_binable) ->
          sig
            module Key :
              sig
                type t = Key.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator = Key.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type 'a t = (Key.t, 'a, Key.comparator) Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> 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) ->
                  'a Core_kernel.Validate.check ->
                  'a t Core_kernel.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t *
                   [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                  list
                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:('a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val t_of_sexp :
                  (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              end
            type 'a t = (Key.t, 'a, Key.comparator) t
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> 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) ->
              'a Core_kernel.Validate.check ->
              'a t Core_kernel.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
              list
            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:('a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
            val next_key : 'a t -> Key.t -> (Key.t * 'a) option
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
            val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
            val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
            val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
            val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
            val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_read_t__ :
              ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
            val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
            val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
          end
    end
  module Monad :
    sig
      module type Basic =
        sig
          type 'a t
          val bind : 'a t -> ('a -> 'b t) -> 'b t
          val return : 'a -> 'a t
        end
      module type Infix =
        sig
          type 'a t
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      module type S =
        sig
          type 'a t
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
            end
          val bind : 'a t -> ('a -> 'b t) -> 'b t
          val return : 'a -> 'a t
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore : 'a t -> unit t
          val all : 'a t list -> 'a list t
          val all_ignore : unit t list -> unit t
        end
      module Make :
        functor (M : Basic) ->
          sig
            val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
            val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
            module Monad_infix :
              sig
                val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
                val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
              end
            val bind : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
            val return : 'a -> 'a M.t
            val map : 'a M.t -> f:('a -> 'b) -> 'b M.t
            val join : 'a M.t M.t -> 'a M.t
            val ignore : 'a M.t -> unit M.t
            val all : 'a M.t list -> 'a list M.t
            val all_ignore : unit M.t list -> unit M.t
          end
      module type Basic2 =
        sig
          type ('a, 'd) t
          val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val return : 'a -> ('a, 'b) t
        end
      module type Infix2 =
        sig
          type ('a, 'd) t
          val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
        end
      module type S2 =
        sig
          type ('a, 'd) t
          val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
              val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
            end
          val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val return : 'a -> ('a, 'b) t
          val map : ('a, 'd) t -> f:('a -> 'b) -> ('b, 'd) t
          val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
          val ignore : ('a, 'd) t -> (unit, 'd) t
          val all : ('a, 'd) t list -> ('a list, 'd) t
          val all_ignore : (unit, 'd) t list -> (unit, 'd) t
        end
      module Check_S2_refines_S :
        functor (X : S) ->
          sig
            type ('a, 'd) t = 'a X.t
            val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
            val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
            module Monad_infix :
              sig
                val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
                val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
              end
            val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
            val return : 'a -> ('a, 'b) t
            val map : ('a, 'd) t -> f:('a -> 'b) -> ('b, 'd) t
            val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
            val ignore : ('a, 'd) t -> (unit, 'd) t
            val all : ('a, 'd) t list -> ('a list, 'd) t
            val all_ignore : (unit, 'd) t list -> (unit, 'd) t
          end
      module Make2 :
        functor (M : Basic2) ->
          sig
            val ( >>= ) :
              ('a, 'd) M.t -> ('a -> ('b, 'd) M.t) -> ('b, 'd) M.t
            val ( >>| ) : ('a, 'd) M.t -> ('a -> 'b) -> ('b, 'd) M.t
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'd) M.t -> ('a -> ('b, 'd) M.t) -> ('b, 'd) M.t
                val ( >>| ) : ('a, 'd) M.t -> ('a -> 'b) -> ('b, 'd) M.t
              end
            val bind : ('a, 'd) M.t -> ('a -> ('b, 'd) M.t) -> ('b, 'd) M.t
            val return : 'a -> ('a, 'b) M.t
            val map : ('a, 'd) M.t -> f:('a -> 'b) -> ('b, 'd) M.t
            val join : (('a, 'd) M.t, 'd) M.t -> ('a, 'd) M.t
            val ignore : ('a, 'd) M.t -> (unit, 'd) M.t
            val all : ('a, 'd) M.t list -> ('a list, 'd) M.t
            val all_ignore : (unit, 'd) M.t list -> (unit, 'd) M.t
          end
    end
  module Nat :
    sig
      type nat = Nat.nat
      external create_nat : int -> nat = "create_nat"
      val make_nat : int -> nat
      external set_to_zero_nat : nat -> int -> int -> unit
        = "set_to_zero_nat"
      external blit_nat : nat -> int -> nat -> int -> int -> unit
        = "blit_nat"
      val copy_nat : nat -> int -> int -> nat
      external set_digit_nat : nat -> int -> int -> unit = "set_digit_nat"
      external nth_digit_nat : nat -> int -> int = "nth_digit_nat"
      external set_digit_nat_native : nat -> int -> nativeint -> unit
        = "set_digit_nat_native"
      external nth_digit_nat_native : nat -> int -> nativeint
        = "nth_digit_nat_native"
      val length_nat : nat -> int
      external num_digits_nat : nat -> int -> int -> int = "num_digits_nat"
      external num_leading_zero_bits_in_digit : nat -> int -> int
        = "num_leading_zero_bits_in_digit"
      external is_digit_int : nat -> int -> bool = "is_digit_int"
      external is_digit_zero : nat -> int -> bool = "is_digit_zero"
      external is_digit_normalized : nat -> int -> bool
        = "is_digit_normalized"
      external is_digit_odd : nat -> int -> bool = "is_digit_odd"
      val is_zero_nat : nat -> int -> int -> bool
      val is_nat_int : nat -> int -> int -> bool
      val int_of_nat : nat -> int
      val nat_of_int : int -> nat
      external incr_nat : nat -> int -> int -> int -> int = "incr_nat"
      external add_nat : nat -> int -> int -> nat -> int -> int -> int -> int
        = "add_nat" "add_nat_native"
      external complement_nat : nat -> int -> int -> unit = "complement_nat"
      external decr_nat : nat -> int -> int -> int -> int = "decr_nat"
      external sub_nat : nat -> int -> int -> nat -> int -> int -> int -> int
        = "sub_nat" "sub_nat_native"
      external mult_digit_nat :
        nat -> int -> int -> nat -> int -> int -> nat -> int -> int
        = "mult_digit_nat" "mult_digit_nat_native"
      external mult_nat :
        nat -> int -> int -> nat -> int -> int -> nat -> int -> int -> int
        = "mult_nat" "mult_nat_native"
      external square_nat : nat -> int -> int -> nat -> int -> int -> int
        = "square_nat" "square_nat_native"
      external shift_left_nat :
        nat -> int -> int -> nat -> int -> int -> unit = "shift_left_nat"
        "shift_left_nat_native"
      external div_digit_nat :
        nat -> int -> nat -> int -> nat -> int -> int -> nat -> int -> unit
        = "div_digit_nat" "div_digit_nat_native"
      external div_nat : nat -> int -> int -> nat -> int -> int -> unit
        = "div_nat" "div_nat_native"
      external shift_right_nat :
        nat -> int -> int -> nat -> int -> int -> unit = "shift_right_nat"
        "shift_right_nat_native"
      external compare_digits_nat : nat -> int -> nat -> int -> int
        = "compare_digits_nat"
      external compare_nat : nat -> int -> int -> nat -> int -> int -> int
        = "compare_nat" "compare_nat_native"
      val eq_nat : nat -> int -> int -> nat -> int -> int -> bool
      val le_nat : nat -> int -> int -> nat -> int -> int -> bool
      val lt_nat : nat -> int -> int -> nat -> int -> int -> bool
      val ge_nat : nat -> int -> int -> nat -> int -> int -> bool
      val gt_nat : nat -> int -> int -> nat -> int -> int -> bool
      external land_digit_nat : nat -> int -> nat -> int -> unit
        = "land_digit_nat"
      external lor_digit_nat : nat -> int -> nat -> int -> unit
        = "lor_digit_nat"
      external lxor_digit_nat : nat -> int -> nat -> int -> unit
        = "lxor_digit_nat"
      val gcd_nat : nat -> int -> int -> nat -> int -> int -> int
      val sqrt_nat : nat -> int -> int -> nat
      val string_of_nat : nat -> string
      val nat_of_string : string -> nat
      val sys_nat_of_string : int -> string -> int -> int -> nat
      val float_of_nat : nat -> float
      val make_power_base : int -> nat -> int * int
      val power_base_int : int -> int -> nat
      val length_of_digit : int
      val sexp_of_nat : Nat.nat -> Sexplib.Sexp.t
      val nat_of_sexp : Sexplib.Sexp.t -> Nat.nat
    end
  module Nativeint :
    sig
      type t = nativeint
      val of_float : float -> t
      val to_float : t -> float
      val of_int_exn : int -> t
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Core_nativeint.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Core_nativeint.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      val validate_positive : t Core_kernel.Validate.check
      val validate_non_negative : t Core_kernel.Validate.check
      val validate_negative : t Core_kernel.Validate.check
      val validate_non_positive : t Core_kernel.Validate.check
      val is_positive : t -> bool
      val is_non_negative : t -> bool
      val is_negative : t -> bool
      val is_non_positive : t -> bool
      val to_string_hum : ?delimiter:char -> t -> string
      val num_bits : int
      val zero : t
      val one : t
      val minus_one : t
      val ( + ) : t -> t -> t
      val ( - ) : t -> t -> t
      val ( * ) : t -> t -> t
      val ( / ) : t -> t -> t
      val neg : t -> t
      val succ : t -> t
      val pred : t -> t
      val abs : t -> t
      val rem : t -> t -> t
      val max_value : t
      val min_value : t
      val bit_and : t -> t -> t
      val bit_or : t -> t -> t
      val bit_xor : t -> t -> t
      val bit_not : t -> t
      val decr : t ref -> unit
      val incr : t ref -> unit
      val shift_left : t -> int -> t
      val shift_right : t -> int -> t
      val shift_right_logical : t -> int -> t
      val of_int32_exn : int32 -> t
      val of_int64_exn : int64 -> t
      val to_int64 : t -> int64
      val of_nativeint_exn : nativeint -> t
      val to_nativeint_exn : t -> nativeint
      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
      val of_int : int -> t
      val to_int : t -> int option
      val to_int_exn : t -> int
      val of_int32 : int32 -> t
      val to_int32 : t -> int32 option
      val to_int32_exn : t -> int32
      val of_int64 : int64 -> t option
      val of_nativeint : nativeint -> t
      val to_nativeint : t -> nativeint
    end
  module Num :
    sig
      type num =
        Num.num =
          Int of int
        | Big_int of Big_int.big_int
        | Ratio of Ratio.ratio
      val ( +/ ) : num -> num -> num
      val add_num : num -> num -> num
      val minus_num : num -> num
      val ( -/ ) : num -> num -> num
      val sub_num : num -> num -> num
      val ( */ ) : num -> num -> num
      val mult_num : num -> num -> num
      val square_num : num -> num
      val ( // ) : num -> num -> num
      val div_num : num -> num -> num
      val quo_num : num -> num -> num
      val mod_num : num -> num -> num
      val ( **/ ) : num -> num -> num
      val power_num : num -> num -> num
      val abs_num : num -> num
      val succ_num : num -> num
      val pred_num : num -> num
      val incr_num : num ref -> unit
      val decr_num : num ref -> unit
      val is_integer_num : num -> bool
      val integer_num : num -> num
      val floor_num : num -> num
      val round_num : num -> num
      val ceiling_num : num -> num
      val sign_num : num -> int
      val ( =/ ) : num -> num -> bool
      val ( </ ) : num -> num -> bool
      val ( >/ ) : num -> num -> bool
      val ( <=/ ) : num -> num -> bool
      val ( >=/ ) : num -> num -> bool
      val ( <>/ ) : num -> num -> bool
      val eq_num : num -> num -> bool
      val lt_num : num -> num -> bool
      val le_num : num -> num -> bool
      val gt_num : num -> num -> bool
      val ge_num : num -> num -> bool
      val compare_num : num -> num -> int
      val max_num : num -> num -> num
      val min_num : num -> num -> num
      val string_of_num : num -> string
      val approx_num_fix : int -> num -> string
      val approx_num_exp : int -> num -> string
      val num_of_string : string -> num
      val int_of_num : num -> int
      val num_of_int : int -> num
      val nat_of_num : num -> Nat.nat
      val num_of_nat : Nat.nat -> num
      val num_of_big_int : Big_int.big_int -> num
      val big_int_of_num : num -> Big_int.big_int
      val ratio_of_num : num -> Ratio.ratio
      val num_of_ratio : Ratio.ratio -> num
      val float_of_num : num -> float
      val sexp_of_num : Num.num -> Sexplib.Sexp.t
      val num_of_sexp : Sexplib.Sexp.t -> Num.num
    end
  module Option :
    sig
      type 'a t = 'a option
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val count : 'a t -> f:('a -> bool) -> int
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      val bind : 'a t -> ('a -> 'b t) -> 'b t
      val return : 'a -> 'a t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      val is_none : 'a t -> bool
      val is_some : 'a t -> bool
      val value_map : 'a t -> default:'b -> f:('a -> 'b) -> 'b
      val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
      val call : 'a -> f:('a -> unit) t -> unit
      val apply : 'a -> f:('a -> 'b) t -> 'b t
      val value : 'a t -> default:'a -> 'a
      val value_exn :
        ?here:Core_kernel.Source_code_position0.t ->
        ?error:Core_kernel.Error.t -> ?message:string -> 'a t -> 'a
      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      val some : 'a -> 'a t
      val both : 'a t -> 'b t -> ('a * 'b) t
      val first_some : 'a t -> 'a t -> 'a t
      val some_if : bool -> 'a -> 'a t
      val merge : 'a t -> 'a t -> f:('a -> 'a -> 'a) -> 'a t
      val filter : f:('a -> bool) -> 'a t -> 'a t
      val try_with : (unit -> 'a) -> 'a t
      val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
      val validate :
        none:unit Core_kernel.Validate.check ->
        some:'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
    end
  module Out_channel :
    sig
      type t = out_channel
      val stdout : t
      val stderr : t
      type 'a with_create_args =
          ?binary:bool -> ?append:bool -> ?perm:int -> 'a
      val create : (string -> t) with_create_args
      val with_file : (string -> f:(t -> 'a) -> 'a) with_create_args
      val close : t -> unit
      val set_binary_mode : t -> bool -> unit
      val flush : t -> unit
      val output : t -> buf:string -> pos:int -> len:int -> unit
      val output_string : t -> string -> unit
      val output_char : t -> char -> unit
      val output_byte : t -> int -> unit
      val output_binary_int : t -> int -> unit
      val output_value : t -> 'a -> unit
      val newline : t -> unit
      val output_lines : t -> string list -> unit
      val seek : t -> int64 -> unit
      val pos : t -> int64
      val length : t -> int64
      val write_lines : string -> string list -> unit
      val write_all : string -> data:string -> unit
    end
  module Printexc :
    sig
      val to_string : exn -> [ `Deprecated_use_Exn_to_string_instead ]
      val print : exn -> [ `Deprecated_use_Exn_to_string_instead ]
      val catch :
        ('a -> 'b) -> 'a -> [ `Deprecated_use_Exn_handle_uncaught_instead ]
      val print_backtrace : out_channel -> unit
      val get_backtrace : unit -> string
      val record_backtrace : bool -> unit
      val backtrace_status : unit -> bool
    end
  module Printf :
    sig
      val fprintf : out_channel -> ('r, out_channel, unit) format -> 'r
      val printf : ('r, out_channel, unit) format -> 'r
      val eprintf : ('r, out_channel, unit) format -> 'r
      val ifprintf : 'a -> ('r, 'a, unit) format -> 'r
      val sprintf : ('r, unit, string) format -> 'r
      val bprintf : Buffer.t -> ('r, Buffer.t, unit) format -> 'r
      val kfprintf :
        (out_channel -> 'a) ->
        out_channel -> ('r, out_channel, unit, 'a) format4 -> 'r
      val ksprintf : (string -> 'a) -> ('r, unit, string, 'a) format4 -> 'r
      val kbprintf :
        (Buffer.t -> 'a) ->
        Buffer.t -> ('r, Buffer.t, unit, 'a) format4 -> 'r
      val failwithf : ('r, unit, string, unit -> 'a) format4 -> 'r
      val invalid_argf : ('r, unit, string, unit -> 'a) format4 -> 'r
      val exitf : ('r, unit, string, unit -> 'a) format4 -> 'r
    end
  val fprintf : out_channel -> ('r, out_channel, unit) format -> 'r
  val printf : ('r, out_channel, unit) format -> 'r
  val eprintf : ('r, out_channel, unit) format -> 'r
  val ifprintf : 'a -> ('r, 'a, unit) format -> 'r
  val sprintf : ('r, unit, string) format -> 'r
  val bprintf : Buffer.t -> ('r, Buffer.t, unit) format -> 'r
  val kfprintf :
    (out_channel -> 'a) ->
    out_channel -> ('r, out_channel, unit, 'a) format4 -> 'r
  val ksprintf : (string -> 'a) -> ('r, unit, string, 'a) format4 -> 'r
  val kbprintf :
    (Buffer.t -> 'a) -> Buffer.t -> ('r, Buffer.t, unit, 'a) format4 -> 'r
  val failwithf : ('r, unit, string, unit -> 'a) format4 -> 'r
  val invalid_argf : ('r, unit, string, unit -> 'a) format4 -> 'r
  val exitf : ('r, unit, string, unit -> 'a) format4 -> 'r
  module Queue :
    sig
      type 'a t = 'a Core_kernel.Core_queue.t
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val count : 'a t -> f:('a -> bool) -> int
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val create : unit -> 'a t
      val enqueue : 'a t -> 'a -> unit
      val dequeue : 'a t -> 'a option
      val dequeue_exn : 'a t -> 'a
      val peek : 'a t -> 'a option
      val peek_exn : 'a t -> 'a
      val clear : 'a t -> unit
      val copy : 'a t -> 'a t
      val filter_inplace : 'a t -> f:('a -> bool) -> unit
      val transfer : src:'a t -> dst:'a t -> unit
      val of_list : 'a list -> 'a t
      val to_list : 'a t -> 'a list
      val partial_iter : 'a t -> f:('a -> [ `Continue | `Stop ]) -> unit
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val concat_map : 'a t -> f:('a -> 'b list) -> 'b t
      val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val of_array : 'a array -> 'a t
      val to_array : 'a t -> 'a array
      val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
      val singleton : 'a -> 'a t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
    end
  module Random :
    sig
      val init : int -> unit
      val full_init : int array -> unit
      val self_init : unit -> unit
      val bits : unit -> int
      val int : int -> int
      val int32 : Int32.t -> Int32.t
      val nativeint : Nativeint.t -> Nativeint.t
      val int64 : Int64.t -> Int64.t
      val float : float -> float
      val bool : unit -> bool
      module State :
        sig
          type t = Core_kernel.Core_random.State.t
          val default : t
          val make : int array -> t
          val make_self_init : unit -> t
          val copy : t -> t
          val bits : t -> int
          val int : t -> int -> int
          val int32 : t -> Int32.t -> Int32.t
          val nativeint : t -> Nativeint.t -> Nativeint.t
          val int64 : t -> Int64.t -> Int64.t
          val float : t -> float -> float
          val bool : t -> bool
        end
      val get_state : unit -> [ `Consider_using_Random_State_default ]
      val set_state : State.t -> unit
    end
  module Ratio :
    sig
      type ratio = Ratio.ratio
      val null_denominator : ratio -> bool
      val numerator_ratio : ratio -> Big_int.big_int
      val denominator_ratio : ratio -> Big_int.big_int
      val sign_ratio : ratio -> int
      val normalize_ratio : ratio -> ratio
      val cautious_normalize_ratio : ratio -> ratio
      val cautious_normalize_ratio_when_printing : ratio -> ratio
      val create_ratio : Big_int.big_int -> Big_int.big_int -> ratio
      val create_normalized_ratio :
        Big_int.big_int -> Big_int.big_int -> ratio
      val is_normalized_ratio : ratio -> bool
      val report_sign_ratio : ratio -> Big_int.big_int -> Big_int.big_int
      val abs_ratio : ratio -> ratio
      val is_integer_ratio : ratio -> bool
      val add_ratio : ratio -> ratio -> ratio
      val minus_ratio : ratio -> ratio
      val add_int_ratio : int -> ratio -> ratio
      val add_big_int_ratio : Big_int.big_int -> ratio -> ratio
      val sub_ratio : ratio -> ratio -> ratio
      val mult_ratio : ratio -> ratio -> ratio
      val mult_int_ratio : int -> ratio -> ratio
      val mult_big_int_ratio : Big_int.big_int -> ratio -> ratio
      val square_ratio : ratio -> ratio
      val inverse_ratio : ratio -> ratio
      val div_ratio : ratio -> ratio -> ratio
      val integer_ratio : ratio -> Big_int.big_int
      val floor_ratio : ratio -> Big_int.big_int
      val round_ratio : ratio -> Big_int.big_int
      val ceiling_ratio : ratio -> Big_int.big_int
      val eq_ratio : ratio -> ratio -> bool
      val compare_ratio : ratio -> ratio -> int
      val lt_ratio : ratio -> ratio -> bool
      val le_ratio : ratio -> ratio -> bool
      val gt_ratio : ratio -> ratio -> bool
      val ge_ratio : ratio -> ratio -> bool
      val max_ratio : ratio -> ratio -> ratio
      val min_ratio : ratio -> ratio -> ratio
      val eq_big_int_ratio : Big_int.big_int -> ratio -> bool
      val compare_big_int_ratio : Big_int.big_int -> ratio -> int
      val lt_big_int_ratio : Big_int.big_int -> ratio -> bool
      val le_big_int_ratio : Big_int.big_int -> ratio -> bool
      val gt_big_int_ratio : Big_int.big_int -> ratio -> bool
      val ge_big_int_ratio : Big_int.big_int -> ratio -> bool
      val int_of_ratio : ratio -> int
      val ratio_of_int : int -> ratio
      val ratio_of_nat : Nat.nat -> ratio
      val nat_of_ratio : ratio -> Nat.nat
      val ratio_of_big_int : Big_int.big_int -> ratio
      val big_int_of_ratio : ratio -> Big_int.big_int
      val div_int_ratio : int -> ratio -> ratio
      val div_ratio_int : ratio -> int -> ratio
      val div_big_int_ratio : Big_int.big_int -> ratio -> ratio
      val div_ratio_big_int : ratio -> Big_int.big_int -> ratio
      val approx_ratio_fix : int -> ratio -> string
      val approx_ratio_exp : int -> ratio -> string
      val float_of_rational_string : ratio -> string
      val string_of_ratio : ratio -> string
      val ratio_of_string : string -> ratio
      val float_of_ratio : ratio -> float
      val power_ratio_positive_int : ratio -> int -> ratio
      val power_ratio_positive_big_int : ratio -> Big_int.big_int -> ratio
      val sexp_of_ratio : Ratio.ratio -> Sexplib.Sexp.t
      val ratio_of_sexp : Sexplib.Sexp.t -> Ratio.ratio
    end
  module Result :
    sig
      type ('ok, 'err) t =
        ('ok, 'err) Core_kernel.Result.t =
          Ok of 'ok
        | Error of 'err
      val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
      val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
        end
      val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
      val return : 'a -> ('a, 'b) t
      val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
      val ignore : ('a, 'd) t -> (unit, 'd) t
      val all : ('a, 'd) t list -> ('a list, 'd) t
      val all_ignore : (unit, 'd) t list -> (unit, 'd) t
      val fail : 'err -> ('a, 'err) t
      val failf : ('a, unit, string, ('b, string) t) format4 -> 'a
      val is_ok : ('a, 'b) t -> bool
      val is_error : ('a, 'b) t -> bool
      val ok : ('ok, 'a) t -> 'ok option
      val error : ('a, 'err) t -> 'err option
      val of_option : 'ok option -> error:'err -> ('ok, 'err) t
      val iter : ('ok, 'a) t -> f:('ok -> unit) -> unit
      val iter_error : ('a, 'err) t -> f:('err -> unit) -> unit
      val map : ('ok, 'err) t -> f:('ok -> 'c) -> ('c, 'err) t
      val map_error : ('ok, 'err) t -> f:('err -> 'c) -> ('ok, 'c) t
      val combine :
        ('ok1, 'err) t ->
        ('ok2, 'err) t ->
        ok:('ok1 -> 'ok2 -> 'ok3) ->
        err:('err -> 'err -> 'err) -> ('ok3, 'err) t
      val call : f:('a -> unit, 'b) t -> 'a -> unit
      val apply : f:('a -> 'b, 'err) t -> 'a -> ('b, 'err) t
      val ok_fst : ('ok, 'err) t -> [ `Fst of 'ok | `Snd of 'err ]
      val ok_if_true : bool -> error:'err -> (unit, 'err) t
      val try_with : (unit -> 'a) -> ('a, exn) t
      val ok_exn : ('ok, exn) t -> 'ok
      val ok_or_failwith : ('ok, string) t -> 'ok
      val ok_unit : (unit, 'a) t
      module Export :
        sig
          type ('ok, 'err) _result =
            ('ok, 'err) t =
              Ok of 'ok
            | Error of 'err
          val is_ok : ('a, 'b) t -> bool
          val is_error : ('a, 'b) t -> bool
        end
      module Stable :
        sig
          module V1 :
            sig
              type ('a, 'b) t = ('a, 'b) t
              val compare :
                ('a -> 'a -> int) ->
                ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
              val bin_t :
                'a Bin_prot.Type_class.t ->
                'b Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
              val bin_read_t :
                'a Bin_prot.Unsafe_read_c.reader ->
                'b Bin_prot.Unsafe_read_c.reader ->
                ('a, 'b) t Bin_prot.Read_ml.reader
              val bin_read_t_ :
                'a Bin_prot.Unsafe_read_c.reader ->
                'b Bin_prot.Unsafe_read_c.reader ->
                ('a, 'b) t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ :
                'a Bin_prot.Unsafe_read_c.reader ->
                'b Bin_prot.Unsafe_read_c.reader ->
                (int -> ('a, 'b) t) Bin_prot.Unsafe_read_c.reader
              val bin_reader_t :
                'a Bin_prot.Type_class.reader ->
                'b Bin_prot.Type_class.reader ->
                ('a, 'b) t Bin_prot.Type_class.reader
              val bin_size_t :
                'a Bin_prot.Size.sizer ->
                'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
              val bin_write_t :
                'a Bin_prot.Unsafe_write_c.writer ->
                'b Bin_prot.Unsafe_write_c.writer ->
                ('a, 'b) t Bin_prot.Write_ml.writer
              val bin_write_t_ :
                'a Bin_prot.Unsafe_write_c.writer ->
                'b Bin_prot.Unsafe_write_c.writer ->
                ('a, 'b) t Bin_prot.Unsafe_write_c.writer
              val bin_writer_t :
                'a Bin_prot.Type_class.writer ->
                'b Bin_prot.Type_class.writer ->
                ('a, 'b) t Bin_prot.Type_class.writer
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) ->
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) ->
                ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
            end
          module V1_stable_unit_test :
            sig
              type t = Core_kernel.Result.Stable.V1_stable_unit_test.t
              val equal : t -> t -> bool
              val tests : (t * string * string) list
              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
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
        end
      val compare :
        ('ok -> 'ok -> int) ->
        ('err -> 'err -> int) -> ('ok, 'err) t -> ('ok, 'err) t -> int
      val t_of_sexp :
        (Sexplib.Sexp.t -> 'ok) ->
        (Sexplib.Sexp.t -> 'err) -> Sexplib.Sexp.t -> ('ok, 'err) t
      val sexp_of_t :
        ('ok -> Sexplib.Sexp.t) ->
        ('err -> Sexplib.Sexp.t) -> ('ok, 'err) t -> Sexplib.Sexp.t
      val bin_t :
        'ok Bin_prot.Type_class.t ->
        'err Bin_prot.Type_class.t -> ('ok, 'err) t Bin_prot.Type_class.t
      val bin_read_t :
        'ok Bin_prot.Unsafe_read_c.reader ->
        'err Bin_prot.Unsafe_read_c.reader ->
        ('ok, 'err) t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'ok Bin_prot.Unsafe_read_c.reader ->
        'err Bin_prot.Unsafe_read_c.reader ->
        ('ok, 'err) t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'ok Bin_prot.Unsafe_read_c.reader ->
        'err Bin_prot.Unsafe_read_c.reader ->
        (int -> ('ok, 'err) t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'ok Bin_prot.Type_class.reader ->
        'err Bin_prot.Type_class.reader ->
        ('ok, 'err) t Bin_prot.Type_class.reader
      val bin_size_t :
        'ok Bin_prot.Size.sizer ->
        'err Bin_prot.Size.sizer -> ('ok, 'err) t Bin_prot.Size.sizer
      val bin_write_t :
        'ok Bin_prot.Unsafe_write_c.writer ->
        'err Bin_prot.Unsafe_write_c.writer ->
        ('ok, 'err) t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'ok Bin_prot.Unsafe_write_c.writer ->
        'err Bin_prot.Unsafe_write_c.writer ->
        ('ok, 'err) t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'ok Bin_prot.Type_class.writer ->
        'err Bin_prot.Type_class.writer ->
        ('ok, 'err) t Bin_prot.Type_class.writer
      val while_ok :
        'a list -> f:(int -> 'a -> ('b, 'e) t) -> ('b list, 'e) t
      val output_result : 'a -> [> `output of 'a ]
      val output_ok : 'a -> [> `output of ('a, 'b) t ]
      val output_error : 'a -> [> `output of ('b, 'a) t ]
    end
  type ('ok, 'err) _result = ('ok, 'err) Result.t = Ok of 'ok | Error of 'err
  val is_ok : ('a, 'b) Result.t -> bool
  val is_error : ('a, 'b) Result.t -> bool
  module Set :
    sig
      type ('elt, 'cmp) t = ('elt, 'cmp) Core_kernel.Core_set.t
      module Tree :
        sig
          type ('a, 'cmp) t = ('a, 'cmp) Core_kernel.Core_set.Tree.t
          val length : ('a, 'b) t -> int
          val is_empty : ('a, 'b) t -> bool
          val iter : ('a, 'b) t -> f:('a -> unit) -> unit
          val fold :
            ('a, 'b) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : ('a, 'b) t -> f:('a -> bool) -> bool
          val for_all : ('a, 'b) t -> f:('a -> bool) -> bool
          val count : ('a, 'b) t -> f:('a -> bool) -> int
          val find : ('a, 'b) t -> f:('a -> bool) -> 'a option
          val find_map : ('a, 'c) t -> f:('a -> 'b option) -> 'b option
          val to_list : ('a, 'b) t -> 'a list
          val to_array : ('a, 'b) t -> 'a array
          val invariants :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> bool
          val mem :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> 'a -> bool
          val add :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
          val remove :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
          val union :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
          val inter :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
          val diff :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
          val compare_direct :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> ('a, 'cmp) t -> int
          val equal :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> ('a, 'cmp) t -> bool
          val subset :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> ('a, 'cmp) t -> bool
          val fold_until :
            ('a, 'b) t ->
            init:'accum ->
            f:('accum -> 'a -> [ `Continue of 'accum | `Stop of 'accum ]) ->
            'accum
          val fold_right :
            ('a, 'b) t -> init:'accum -> f:('a -> 'accum -> 'accum) -> 'accum
          val iter2 :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t ->
            ('a, 'cmp) t ->
            f:([ `Both of 'a * 'a | `Left of 'a | `Right of 'a ] -> unit) ->
            unit
          val filter :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t
          val partition_tf :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t
          val elements : ('a, 'b) t -> 'a list
          val min_elt : ('a, 'b) t -> 'a option
          val min_elt_exn : ('a, 'b) t -> 'a
          val max_elt : ('a, 'b) t -> 'a option
          val max_elt_exn : ('a, 'b) t -> 'a
          val choose : ('a, 'b) t -> 'a option
          val choose_exn : ('a, 'b) t -> 'a
          val split :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * bool * ('a, 'cmp) t
          val group_by :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list
          val find_exn : ('a, 'b) t -> f:('a -> bool) -> 'a
          val find_index : ('a, 'b) t -> int -> 'a option
          val remove_index :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> int -> ('a, 'cmp) t
          val to_tree : ('a, 'cmp) t -> ('a, 'cmp) t
          val empty :
            comparator:('a, 'cmp) Core_kernel.Comparator.t -> ('a, 'cmp) t
          val singleton :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            'a -> ('a, 'cmp) t
          val union_list :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t list -> ('a, 'cmp) t
          val of_list :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            'a list -> ('a, 'cmp) t
          val of_array :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            'a array -> ('a, 'cmp) t
          val of_sorted_array :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            'a array -> ('a, 'cmp) t Core_kernel.Or_error.t
          val of_sorted_array_unchecked :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            'a array -> ('a, 'cmp) t
          val stable_dedup_list :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            'a list -> 'a list
          val map :
            comparator:('b, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'c) t -> f:('a -> 'b) -> ('b, 'cmp) t
          val filter_map :
            comparator:('b, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'c) t -> f:('a -> 'b option) -> ('b, 'cmp) t
          val of_tree :
            comparator:('a, 'cmp) Core_kernel.Comparator.t ->
            ('a, 'cmp) t -> ('a, 'cmp) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('cmp -> Sexplib.Sexp.t) -> ('a, 'cmp) t -> Sexplib.Sexp.t
        end
      val invariants : ('a, 'b) t -> bool
      val comparator : ('a, 'cmp) t -> ('a, 'cmp) Core_kernel.Comparator.t
      val empty :
        comparator:('a, 'cmp) Core_kernel.Comparator.t -> ('a, 'cmp) t
      val singleton :
        comparator:('a, 'cmp) Core_kernel.Comparator.t -> 'a -> ('a, 'cmp) t
      val length : ('a, 'b) t -> int
      val is_empty : ('a, 'b) t -> bool
      val mem : ('a, 'b) t -> 'a -> bool
      val add : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
      val remove : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
      val union : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
      val union_list :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a, 'cmp) t list -> ('a, 'cmp) t
      val inter : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
      val diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
      val compare_direct : ('a, 'cmp) t -> ('a, 'cmp) t -> int
      val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> bool
      val exists : ('a, 'b) t -> f:('a -> bool) -> bool
      val for_all : ('a, 'b) t -> f:('a -> bool) -> bool
      val count : ('a, 'b) t -> f:('a -> bool) -> int
      val find : ('a, 'b) t -> f:('a -> bool) -> 'a option
      val find_map : ('a, 'c) t -> f:('a -> 'b option) -> 'b option
      val find_exn : ('a, 'b) t -> f:('a -> bool) -> 'a
      val find_index : ('a, 'b) t -> int -> 'a option
      val remove_index : ('a, 'cmp) t -> int -> ('a, 'cmp) t
      val subset : ('a, 'cmp) t -> ('a, 'cmp) t -> bool
      val of_list :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        'a list -> ('a, 'cmp) t
      val of_array :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        'a array -> ('a, 'cmp) t
      val to_list : ('a, 'b) t -> 'a list
      val to_array : ('a, 'b) t -> 'a array
      val to_tree : ('a, 'cmp) t -> ('a, 'cmp) Tree.t
      val of_tree :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        ('a, 'cmp) Tree.t -> ('a, 'cmp) t
      val of_sorted_array :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        'a array -> ('a, 'cmp) t Core_kernel.Or_error.t
      val of_sorted_array_unchecked :
        comparator:('a, 'cmp) Core_kernel.Comparator.t ->
        'a array -> ('a, 'cmp) t
      val stable_dedup_list :
        comparator:('a, 'b) Core_kernel.Comparator.t -> 'a list -> 'a list
      val map :
        comparator:('b, 'cmp) Core_kernel.Comparator.t ->
        ('a, 'c) t -> f:('a -> 'b) -> ('b, 'cmp) t
      val filter_map :
        comparator:('b, 'cmp) Core_kernel.Comparator.t ->
        ('a, 'c) t -> f:('a -> 'b option) -> ('b, 'cmp) t
      val filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t
      val fold :
        ('a, 'b) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val fold_until :
        ('a, 'b) t ->
        init:'accum ->
        f:('accum -> 'a -> [ `Continue of 'accum | `Stop of 'accum ]) ->
        'accum
      val fold_right :
        ('a, 'b) t -> init:'accum -> f:('a -> 'accum -> 'accum) -> 'accum
      val iter : ('a, 'b) t -> f:('a -> unit) -> unit
      val iter2 :
        ('a, 'cmp) t ->
        ('a, 'cmp) t ->
        f:([ `Both of 'a * 'a | `Left of 'a | `Right of 'a ] -> unit) -> unit
      val partition_tf :
        ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t
      val elements : ('a, 'b) t -> 'a list
      val min_elt : ('a, 'b) t -> 'a option
      val min_elt_exn : ('a, 'b) t -> 'a
      val max_elt : ('a, 'b) t -> 'a option
      val max_elt_exn : ('a, 'b) t -> 'a
      val choose : ('a, 'b) t -> 'a option
      val choose_exn : ('a, 'b) t -> 'a
      val split : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * bool * ('a, 'cmp) t
      val group_by :
        ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list
      module Poly :
        sig
          module Tree :
            sig
              type 'elt t =
                  ('elt, Core_kernel.Comparator.Poly.comparator) Tree.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('a -> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
              val exists : 'a t -> f:('a -> bool) -> bool
              val for_all : 'a t -> f:('a -> bool) -> bool
              val count : 'a t -> f:('a -> bool) -> int
              val find : 'a t -> f:('a -> bool) -> 'a option
              val find_map : 'a t -> f:('a -> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val invariants : 'a t -> bool
              val mem : 'a t -> 'a -> bool
              val add : 'a t -> 'a -> 'a t
              val remove : 'a t -> 'a -> 'a t
              val union : 'a t -> 'a t -> 'a t
              val inter : 'a t -> 'a t -> 'a t
              val diff : 'a t -> 'a t -> 'a t
              val compare_direct : 'a t -> 'a t -> int
              val equal : 'a t -> 'a t -> bool
              val subset : 'a t -> 'a t -> bool
              val fold_until :
                'a t ->
                init:'b ->
                f:('b -> 'a -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b
              val iter2 :
                'a t ->
                'a t ->
                f:([ `Both of 'a * 'a | `Left of 'a | `Right of 'a ] -> unit) ->
                unit
              val filter : 'a t -> f:('a -> bool) -> 'a t
              val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
              val elements : 'a t -> 'a list
              val min_elt : 'a t -> 'a option
              val min_elt_exn : 'a t -> 'a
              val max_elt : 'a t -> 'a option
              val max_elt_exn : 'a t -> 'a
              val choose : 'a t -> 'a option
              val choose_exn : 'a t -> 'a
              val split : 'a t -> 'a -> 'a t * bool * 'a t
              val group_by : 'a t -> equiv:('a -> 'a -> bool) -> 'a t list
              val find_exn : 'a t -> f:('a -> bool) -> 'a
              val find_index : 'a t -> int -> 'a option
              val remove_index : 'a t -> int -> 'a t
              val to_tree : 'a t -> 'a t
              val empty : 'a t
              val singleton : 'a -> 'a t
              val union_list : 'a t list -> 'a t
              val of_list : 'a list -> 'a t
              val of_array : 'a array -> 'a t
              val of_sorted_array : 'a array -> 'a t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : 'a array -> 'a t
              val stable_dedup_list : 'a list -> 'a list
              val map : ('a, 'c) Tree.t -> f:('a -> 'b) -> 'b t
              val filter_map : ('a, 'c) Tree.t -> f:('a -> 'b option) -> 'b t
              val of_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'elt) -> Sexplib.Sexp.t -> 'elt t
              val sexp_of_t :
                ('elt -> Sexplib.Sexp.t) -> 'elt t -> Sexplib.Sexp.t
            end
          type 'elt t = ('elt, Core_kernel.Comparator.Poly.comparator) t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariants : 'a t -> bool
          val mem : 'a t -> 'a -> bool
          val add : 'a t -> 'a -> 'a t
          val remove : 'a t -> 'a -> 'a t
          val union : 'a t -> 'a t -> 'a t
          val inter : 'a t -> 'a t -> 'a t
          val diff : 'a t -> 'a t -> 'a t
          val compare_direct : 'a t -> 'a t -> int
          val equal : 'a t -> 'a t -> bool
          val subset : 'a t -> 'a t -> bool
          val fold_until :
            'a t ->
            init:'b ->
            f:('b -> 'a -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b
          val iter2 :
            'a t ->
            'a t ->
            f:([ `Both of 'a * 'a | `Left of 'a | `Right of 'a ] -> unit) ->
            unit
          val filter : 'a t -> f:('a -> bool) -> 'a t
          val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
          val elements : 'a t -> 'a list
          val min_elt : 'a t -> 'a option
          val min_elt_exn : 'a t -> 'a
          val max_elt : 'a t -> 'a option
          val max_elt_exn : 'a t -> 'a
          val choose : 'a t -> 'a option
          val choose_exn : 'a t -> 'a
          val split : 'a t -> 'a -> 'a t * bool * 'a t
          val group_by : 'a t -> equiv:('a -> 'a -> bool) -> 'a t list
          val find_exn : 'a t -> f:('a -> bool) -> 'a
          val find_index : 'a t -> int -> 'a option
          val remove_index : 'a t -> int -> 'a t
          val to_tree : 'a t -> 'a Tree.t
          val empty : 'a t
          val singleton : 'a -> 'a t
          val union_list : 'a t list -> 'a t
          val of_list : 'a list -> 'a t
          val of_array : 'a array -> 'a t
          val of_sorted_array : 'a array -> 'a t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : 'a array -> 'a t
          val stable_dedup_list : 'a list -> 'a list
          val map : ('a, 'c) t -> f:('a -> 'b) -> 'b t
          val filter_map : ('a, 'c) t -> f:('a -> 'b option) -> 'b t
          val of_tree : 'a Tree.t -> 'a t
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'elt) -> Sexplib.Sexp.t -> 'elt t
          val sexp_of_t :
            ('elt -> Sexplib.Sexp.t) -> 'elt t -> Sexplib.Sexp.t
          val compare : ('elt -> 'elt -> int) -> 'elt t -> 'elt t -> int
          val bin_t :
            'elt Bin_prot.Type_class.t -> 'elt t Bin_prot.Type_class.t
          val bin_read_t :
            'elt Bin_prot.Unsafe_read_c.reader ->
            'elt t Bin_prot.Read_ml.reader
          val bin_read_t_ :
            'elt Bin_prot.Unsafe_read_c.reader ->
            'elt t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            'elt Bin_prot.Unsafe_read_c.reader ->
            (int -> 'elt t) Bin_prot.Unsafe_read_c.reader
          val bin_reader_t :
            'elt Bin_prot.Type_class.reader ->
            'elt t Bin_prot.Type_class.reader
          val bin_size_t :
            'elt Bin_prot.Size.sizer -> 'elt t Bin_prot.Size.sizer
          val bin_write_t :
            'elt Bin_prot.Unsafe_write_c.writer ->
            'elt t Bin_prot.Write_ml.writer
          val bin_write_t_ :
            'elt Bin_prot.Unsafe_write_c.writer ->
            'elt t Bin_prot.Unsafe_write_c.writer
          val bin_writer_t :
            'elt Bin_prot.Type_class.writer ->
            'elt t Bin_prot.Type_class.writer
        end
      module type Elt = Core_kernel.Core_set_intf.Elt
      module type Elt_binable = Core_kernel.Core_set_intf.Elt_binable
      module type S =
        sig
          module Elt : Core_kernel.Comparator.S
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) Tree.t -> f:('a -> Elt.t) -> t
              val filter_map : ('a, 'b) Tree.t -> f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) t -> f:('a -> Elt.t) -> t
          val filter_map : ('a, 'b) t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
        end
      module type S_binable =
        sig
          module Elt : Core_kernel.Comparator.S
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) Tree.t -> f:('a -> Elt.t) -> t
              val filter_map : ('a, 'b) Tree.t -> f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) t -> f:('a -> Elt.t) -> t
          val filter_map : ('a, 'b) t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Make :
        functor (Elt : Elt) ->
          sig
            module Elt :
              sig
                type t = Elt.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator =
                    Core_kernel.Core_set.Make(Elt).Elt.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) Tree.t -> f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Tree.t -> f:('a -> Elt.t option) -> t
                val of_tree : 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) 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 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 compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val fold_until :
              t ->
              init:'b ->
              f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) t -> f:('a -> Elt.t) -> t
            val filter_map : ('a, 'b) t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
            val compare : t -> t -> int
          end
      module Make_using_comparator :
        functor (Elt : Core_kernel.Comparator.S) ->
          sig
            module Elt :
              sig
                type t = Elt.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator = Elt.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) Tree.t -> f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Tree.t -> f:('a -> Elt.t option) -> t
                val of_tree : 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) 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 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 compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val fold_until :
              t ->
              init:'b ->
              f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) t -> f:('a -> Elt.t) -> t
            val filter_map : ('a, 'b) t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
            val compare : t -> t -> int
          end
      module Make_binable :
        functor (Elt : Elt_binable) ->
          sig
            module Elt :
              sig
                type t = Elt.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator =
                    Core_kernel.Core_set.Make_binable(Elt).Elt.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) Tree.t -> f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Tree.t -> f:('a -> Elt.t option) -> t
                val of_tree : 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) 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 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 compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val fold_until :
              t ->
              init:'b ->
              f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) t -> f:('a -> Elt.t) -> t
            val filter_map : ('a, 'b) t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
            val compare : t -> t -> int
            val bin_size_t : t Bin_prot.Size.sizer
            val bin_write_t : t Bin_prot.Map_to_safe.writer
            val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
            val bin_read_t : t Bin_prot.Read_ml.reader
            val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
            val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
            val bin_writer_t : t Bin_prot.Type_class.writer
            val bin_reader_t : t Bin_prot.Type_class.reader
            val bin_t : t Bin_prot.Type_class.t
          end
      module Make_binable_using_comparator :
        functor (Elt : Core_kernel.Comparator.S_binable) ->
          sig
            module Elt :
              sig
                type t = Elt.t
                val compare : t -> t -> int
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                type comparator = Elt.comparator
                val comparator : (t, comparator) Core_kernel.Comparator.t_
              end
            module Tree :
              sig
                type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) Tree.t -> f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Tree.t -> f:('a -> Elt.t option) -> t
                val of_tree : 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) 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 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 compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val fold_until :
              t ->
              init:'b ->
              f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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) t -> f:('a -> Elt.t) -> t
            val filter_map : ('a, 'b) t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
            val compare : t -> t -> int
            val bin_size_t : t Bin_prot.Size.sizer
            val bin_write_t : t Bin_prot.Map_to_safe.writer
            val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
            val bin_read_t : t Bin_prot.Read_ml.reader
            val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
            val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
            val bin_writer_t : t Bin_prot.Type_class.writer
            val bin_reader_t : t Bin_prot.Type_class.reader
            val bin_t : t Bin_prot.Type_class.t
          end
      val compare :
        ('elt -> 'elt -> int) ->
        ('cmp -> 'cmp -> int) -> ('elt, 'cmp) t -> ('elt, 'cmp) t -> int
    end
  type sexp_bool = bool
  type 'a sexp_option = 'a option
  type 'a sexp_list = 'a list
  type 'a sexp_array = 'a array
  type 'a sexp_opaque = 'a
  type bigstring = Sexplib.Sexp.bigstring
  type float32_vec =
      (float, Bigarray.float32_elt, Bigarray.fortran_layout)
      Bigarray.Array1.t
  type float64_vec =
      (float, Bigarray.float64_elt, Bigarray.fortran_layout)
      Bigarray.Array1.t
  type vec = float64_vec
  type float32_mat =
      (float, Bigarray.float32_elt, Bigarray.fortran_layout)
      Bigarray.Array2.t
  type float64_mat =
      (float, Bigarray.float64_elt, Bigarray.fortran_layout)
      Bigarray.Array2.t
  type mat = float64_mat
  val default_string_of_float : (float -> string) ref
  val write_old_option_format : bool ref
  val read_old_option_format : bool ref
  val list_map : ('a -> 'b) -> 'a list -> 'b list
  val sexp_of_unit : unit -> Sexplib.Sexp.t
  val sexp_of_bool : bool -> Sexplib.Sexp.t
  val sexp_of_string : string -> Sexplib.Sexp.t
  val sexp_of_char : char -> Sexplib.Sexp.t
  val sexp_of_int : int -> Sexplib.Sexp.t
  val sexp_of_float : float -> Sexplib.Sexp.t
  val sexp_of_int32 : int32 -> Sexplib.Sexp.t
  val sexp_of_int64 : int64 -> Sexplib.Sexp.t
  val sexp_of_nativeint : nativeint -> Sexplib.Sexp.t
  val sexp_of_big_int : Big_int.big_int -> Sexplib.Sexp.t
  val sexp_of_nat : Nat.nat -> Sexplib.Sexp.t
  val sexp_of_num : Num.num -> Sexplib.Sexp.t
  val sexp_of_ratio : Ratio.ratio -> Sexplib.Sexp.t
  val sexp_of_ref : ('a -> Sexplib.Sexp.t) -> 'a ref -> Sexplib.Sexp.t
  val sexp_of_lazy_t : ('a -> Sexplib.Sexp.t) -> 'a lazy_t -> Sexplib.Sexp.t
  val sexp_of_option : ('a -> Sexplib.Sexp.t) -> 'a option -> Sexplib.Sexp.t
  val sexp_of_pair :
    ('a -> Sexplib.Sexp.t) ->
    ('b -> Sexplib.Sexp.t) -> 'a * 'b -> Sexplib.Sexp.t
  val sexp_of_triple :
    ('a -> Sexplib.Sexp.t) ->
    ('b -> Sexplib.Sexp.t) ->
    ('c -> Sexplib.Sexp.t) -> 'a * 'b * 'c -> Sexplib.Sexp.t
  val sexp_of_list : ('a -> Sexplib.Sexp.t) -> 'a list -> Sexplib.Sexp.t
  val sexp_of_array : ('a -> Sexplib.Sexp.t) -> 'a array -> Sexplib.Sexp.t
  val sexp_of_hashtbl :
    ('a -> Sexplib.Sexp.t) ->
    ('b -> Sexplib.Sexp.t) -> ('a, 'b) Hashtbl.t -> Sexplib.Sexp.t
  val sexp_of_bigstring : bigstring -> Sexplib.Sexp.t
  val sexp_of_float32_vec : float32_vec -> Sexplib.Sexp.t
  val sexp_of_float64_vec : float64_vec -> Sexplib.Sexp.t
  val sexp_of_vec : vec -> Sexplib.Sexp.t
  val sexp_of_float32_mat : float32_mat -> Sexplib.Sexp.t
  val sexp_of_float64_mat : float64_mat -> Sexplib.Sexp.t
  val sexp_of_mat : mat -> Sexplib.Sexp.t
  val sexp_of_opaque : 'a -> Sexplib.Sexp.t
  val sexp_of_fun : ('a -> 'b) -> Sexplib.Sexp.t
  val string_of__of__sexp_of : ('a -> Sexplib.Sexp.t) -> 'a -> string
  exception Of_sexp_error of exn * Sexplib.Sexp.t
  val record_check_extra_fields : bool ref
  val of_sexp_error : string -> Sexplib.Sexp.t -> 'a
  val of_sexp_error_exn : exn -> Sexplib.Sexp.t -> 'a
  val unit_of_sexp : Sexplib.Sexp.t -> unit
  val bool_of_sexp : Sexplib.Sexp.t -> bool
  val string_of_sexp : Sexplib.Sexp.t -> string
  val char_of_sexp : Sexplib.Sexp.t -> char
  val int_of_sexp : Sexplib.Sexp.t -> int
  val float_of_sexp : Sexplib.Sexp.t -> float
  val int32_of_sexp : Sexplib.Sexp.t -> int32
  val int64_of_sexp : Sexplib.Sexp.t -> int64
  val nativeint_of_sexp : Sexplib.Sexp.t -> nativeint
  val big_int_of_sexp : Sexplib.Sexp.t -> Big_int.big_int
  val nat_of_sexp : Sexplib.Sexp.t -> Nat.nat
  val num_of_sexp : Sexplib.Sexp.t -> Num.num
  val ratio_of_sexp : Sexplib.Sexp.t -> Ratio.ratio
  val ref_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a ref
  val lazy_t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a lazy_t
  val option_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a option
  val pair_of_sexp :
    (Sexplib.Sexp.t -> 'a) ->
    (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'a * 'b
  val triple_of_sexp :
    (Sexplib.Sexp.t -> 'a) ->
    (Sexplib.Sexp.t -> 'b) ->
    (Sexplib.Sexp.t -> 'c) -> Sexplib.Sexp.t -> 'a * 'b * 'c
  val list_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a list
  val array_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a array
  val hashtbl_of_sexp :
    (Sexplib.Sexp.t -> 'a) ->
    (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) Hashtbl.t
  val bigstring_of_sexp : Sexplib.Sexp.t -> bigstring
  val float32_vec_of_sexp : Sexplib.Sexp.t -> float32_vec
  val float64_vec_of_sexp : Sexplib.Sexp.t -> float64_vec
  val vec_of_sexp : Sexplib.Sexp.t -> vec
  val float32_mat_of_sexp : Sexplib.Sexp.t -> float32_mat
  val float64_mat_of_sexp : Sexplib.Sexp.t -> float64_mat
  val mat_of_sexp : Sexplib.Sexp.t -> mat
  val opaque_of_sexp : Sexplib.Sexp.t -> 'a
  val fun_of_sexp : Sexplib.Sexp.t -> 'a
  val of_string__of__of_sexp : (Sexplib.Sexp.t -> 'a) -> string -> 'a
  val sexp_of_exn : exn -> Sexplib.Sexp.t
  val sexp_of_exn_opt : exn -> Sexplib.Sexp.t option
  module Exn_converter :
    sig
      type t
      val set_max_exn_tags : int -> unit
      val get_max_exn_tags : unit -> int
      val add_auto : ?finalise:bool -> exn -> (exn -> Sexplib.Sexp.t) -> unit
      val add_slow : (exn -> Sexplib.Sexp.t option) -> t
      val del_slow : t -> unit
    end
  module Stack :
    sig
      type 'a t = 'a Core_kernel.Core_stack.t
      val invariant :
        'a Core_kernel.Invariant_intf.inv ->
        'a t Core_kernel.Invariant_intf.inv
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val count : 'a t -> f:('a -> bool) -> int
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val of_list : 'a list -> 'a t
      val create : unit -> 'a t
      val push : 'a t -> 'a -> unit
      val pop : 'a t -> 'a option
      val pop_exn : 'a t -> 'a
      val top : 'a t -> 'a option
      val top_exn : 'a t -> 'a
      val clear : 'a t -> unit
      val copy : 'a t -> 'a t
      val until_empty : 'a t -> ('a -> unit) -> unit
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Bin_prot.Unsafe_read_c.reader ->
        'a t Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a t) Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Bin_prot.Unsafe_write_c.writer ->
        'a t Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
      val set_auto_shrink : 'a t -> bool -> unit
    end
  module String :
    sig
      type t = string
      val blit : (t, t) Core_kernel.Blit_intf.blit
      val blito : (t, t) Core_kernel.Blit_intf.blito
      val unsafe_blit : (t, t) Core_kernel.Blit_intf.blit
      val sub : (t, t) Core_kernel.Blit_intf.sub
      val subo : (t, t) Core_kernel.Blit_intf.subo
      type elt = char
      val mem : ?equal:(elt -> elt -> bool) -> t -> elt -> bool
      val iter : t -> f:(elt -> unit) -> unit
      val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
      val exists : t -> f:(elt -> bool) -> bool
      val for_all : t -> f:(elt -> bool) -> bool
      val count : t -> f:(elt -> bool) -> int
      val find : t -> f:(elt -> bool) -> elt option
      val find_map : t -> f:(elt -> 'a option) -> 'a option
      val to_list : t -> elt list
      val to_array : t -> elt array
      val of_string : string -> t
      val to_string : t -> string
      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 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 = Core_kernel.Core_string.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hashable : sig type t = t end
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core_kernel.Core_string.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      val pp : Format.formatter -> t -> unit
      val max_length : int
      external length : t -> int = "%string_length"
      external get : t -> int -> char = "%string_safe_get"
      external set : t -> int -> char -> unit = "%string_safe_set"
      external create : int -> t = "caml_create_string"
      val make : int -> char -> t
      val copy : t -> t
      val init : int -> f:(int -> char) -> t
      val fill : t -> pos:int -> len:int -> char -> unit
      val concat : ?sep:t -> t list -> t
      val escaped : t -> t
      val contains : ?pos:int -> ?len:int -> t -> char -> bool
      val uppercase : t -> t
      val lowercase : t -> t
      val capitalize : t -> t
      val uncapitalize : t -> t
      val index : t -> char -> int option
      val index_exn : t -> char -> int
      val rindex : t -> char -> int option
      val rindex_exn : t -> char -> int
      val index_from : t -> int -> char -> int option
      val index_from_exn : t -> int -> char -> int
      val rindex_from : t -> int -> char -> int option
      val rindex_from_exn : t -> int -> char -> int
      val slice : t -> int -> int -> t
      val to_list_rev : t -> char list
      val nget : t -> int -> char
      val nset : t -> int -> char -> unit
      val is_suffix : t -> suffix:t -> bool
      val is_prefix : t -> prefix:t -> bool
      val lsplit2_exn : t -> on:char -> t * t
      val rsplit2_exn : t -> on:char -> t * t
      val lsplit2 : t -> on:char -> (t * t) option
      val rsplit2 : t -> on:char -> (t * t) option
      val split : t -> on:char -> t list
      val split_on_chars : t -> on:char list -> t list
      val split_lines : t -> t list
      val lfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option
      val rfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option
      val lstrip : ?drop:(char -> bool) -> t -> t
      val rstrip : ?drop:(char -> bool) -> t -> t
      val strip : ?drop:(char -> bool) -> t -> t
      val map : t -> f:(char -> char) -> t
      val mapi : t -> f:(int -> char -> char) -> t
      val foldi : t -> init:'a -> f:(int -> 'a -> char -> 'a) -> 'a
      val concat_map : ?sep:t -> t -> f:(char -> t) -> t
      val filter : t -> f:(char -> bool) -> t
      val tr : target:char -> replacement:char -> t -> t
      val tr_inplace : target:char -> replacement:char -> t -> unit
      val chop_suffix_exn : t -> suffix:t -> t
      val chop_prefix_exn : t -> prefix:t -> t
      val chop_suffix : t -> suffix:t -> t option
      val chop_prefix : t -> prefix:t -> t option
      val suffix : t -> int -> t
      val prefix : t -> int -> t
      val drop_suffix : t -> int -> t
      val drop_prefix : t -> int -> t
      val concat_array : ?sep:t -> t array -> t
      external hash : t -> int = "caml_hash_string" "noalloc"
      val equal : t -> t -> bool
      val is_empty : t -> bool
      module Infix : sig val ( </> ) : t -> int * int -> t end
      val of_char : char -> t
      val of_char_list : char list -> t
      module Escaping :
        sig
          val escape_gen_exn :
            escapeworthy_map:(char * char) list ->
            escape_char:char -> (string -> string) Core_kernel.Staged.t
          val escape_gen :
            escapeworthy_map:(char * char) list ->
            escape_char:char -> (string -> string) Core_kernel.Or_error.t
          val escape :
            escapeworthy:char list ->
            escape_char:char -> (string -> string) Core_kernel.Staged.t
          val unescape_gen_exn :
            escapeworthy_map:(char * char) list ->
            escape_char:char -> (string -> string) Core_kernel.Staged.t
          val unescape_gen :
            escapeworthy_map:(char * char) list ->
            escape_char:char -> (string -> string) Core_kernel.Or_error.t
          val unescape :
            escape_char:char -> (string -> string) Core_kernel.Staged.t
          val is_char_escaping : string -> escape_char:char -> int -> bool
          val is_char_escaped : string -> escape_char:char -> int -> bool
          val is_char_literal : string -> escape_char:char -> int -> bool
          val index : string -> escape_char:char -> char -> int option
          val index_exn : string -> escape_char:char -> char -> int
          val rindex : string -> escape_char:char -> char -> int option
          val rindex_exn : string -> escape_char:char -> char -> int
          val index_from :
            string -> escape_char:char -> int -> char -> int option
          val index_from_exn :
            string -> escape_char:char -> int -> char -> int
          val rindex_from :
            string -> escape_char:char -> int -> char -> int option
          val rindex_from_exn :
            string -> escape_char:char -> int -> char -> int
          val split : string -> on:char -> escape_char:char -> string list
          val split_on_chars :
            string -> on:char list -> escape_char:char -> string list
          val lsplit2 :
            string -> on:char -> escape_char:char -> (string * string) option
          val lsplit2_exn :
            string -> on:char -> escape_char:char -> string * string
          val rsplit2 :
            string -> on:char -> escape_char:char -> (string * string) option
          val rsplit2_exn :
            string -> on:char -> escape_char:char -> string * string
        end
      external unsafe_get : string -> int -> char = "%string_unsafe_get"
      external unsafe_set : string -> int -> char -> unit
        = "%string_unsafe_set"
      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
  val ( </> ) : String.t -> int * int -> String.t
  module Sys :
    sig
      val argv : string array
      val executable_name : string
      val file_exists :
        ?follow_symlinks:bool -> string -> [ `No | `Unknown | `Yes ]
      val file_exists_exn : ?follow_symlinks:bool -> string -> bool
      val is_directory :
        ?follow_symlinks:bool -> string -> [ `No | `Unknown | `Yes ]
      val is_file :
        ?follow_symlinks:bool -> string -> [ `No | `Unknown | `Yes ]
      val is_directory_exn : ?follow_symlinks:bool -> string -> bool
      val is_file_exn : ?follow_symlinks:bool -> string -> bool
      val remove : string -> unit
      val rename : string -> string -> unit
      val getenv : string -> string option
      val getenv_exn : string -> string
      val command : string -> int
      val command_exn : string -> unit
      val chdir : string -> unit
      val getcwd : unit -> string
      val readdir : string -> string array
      val fold_dir :
        init:'acc -> f:('acc -> string -> 'acc) -> string -> 'acc
      val ls_dir : string -> string list
      val interactive : bool ref
      val os_type : string
      val word_size : int
      exception Break
      val catch_break : bool -> unit
      val ocaml_version : string
      val execution_mode : unit -> [ `Bytecode | `Native ]
      external c_int_size : unit -> int = "c_int_size" "noalloc"
    end
  module Time :
    sig
      module Zone :
        sig
          type t = Core.Zone.t
          val of_string : string -> t
          val to_string : t -> string
          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 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 = Core.Zone.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
          val compare : t -> t -> int
          val comparator : (t, comparator) Core_kernel.Comparator.t_
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> 'a -> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('a -> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val filter :
                    'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                  val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                  val compare_direct :
                    ('a -> 'a -> int) -> 'a t -> 'a t -> int
                  val equal : ('a -> 'a -> 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) ->
                    'a Core_kernel.Validate.check ->
                    'a t Core_kernel.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('a -> 'a -> bool) ->
                    (Key.t *
                     [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                    list
                  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:('a -> bool) -> bool
                  val exists : 'a t -> f:('a -> bool) -> bool
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                end
              type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a Tree.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'b ->
                    f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
                    'b
                  val fold_right :
                    t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel.Core_set.Tree.t ->
                    f:('a -> Elt.t option) -> t
                  val of_tree : 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) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hashable : sig type t = t end
          val hash : t -> int
          val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Pooled_hashtbl :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type 'a hash_set = 'a Core_kernel.Hash_set.t
              type t = elt hash_set
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, 'a elt_ list -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val hash : t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              type 'a t = 'a Core.Zone.Hash_queue.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('a -> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
              val exists : 'a t -> f:('a -> bool) -> bool
              val for_all : 'a t -> f:('a -> bool) -> bool
              val count : 'a t -> f:('a -> bool) -> int
              val find : 'a t -> f:('a -> bool) -> 'a option
              val find_map : 'a t -> f:('a -> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val invariant : 'a t -> unit
              val create : unit -> 'a t
              val clear : 'a t -> unit
              val mem : 'a t -> Key.t -> bool
              val lookup : 'a t -> Key.t -> 'a option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
              val enqueue_exn : 'a t -> Key.t -> 'a -> unit
              val first : 'a t -> 'a option
              val keys : 'a t -> Key.t list
              val dequeue : 'a t -> 'a option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key : 'a t -> (Key.t * 'a) option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all : 'a t -> f:('a -> unit) -> unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> unit
              val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
              val replace_exn : 'a t -> Key.t -> 'a -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
              val foldi :
                'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
            end
          val pp : Format.formatter -> t -> unit
          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
          val find : string -> t option
          val find_office : [ `chi | `hkg | `ldn | `nyc ] -> t
          val find_exn : string -> t
          val machine_zone : ?refresh:bool -> unit -> t
          val likely_machine_zones : string list ref
          val of_utc_offset : hours:int -> t
          val default_utc_offset_deprecated : t -> int
          val utc : t
          val abbreviation : t -> float -> string
          val name : t -> string
          val init : unit -> unit
          val digest : t -> string option
          val initialized_zones : unit -> (string * t) list
          val shift_epoch_time : t -> [ `Local | `UTC ] -> float -> float
          exception Unknown_zone of string
          exception Invalid_file_format of string
          module Stable :
            sig
              module V1 :
                sig
                  type t = t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
            end
        end
      module Span :
        sig
          type t = Core.Span.t
          module Parts :
            sig
              type t =
                Core.Span.Parts.t = private {
                sign : Core_kernel.Std.Float.Sign.t;
                hr : int;
                min : int;
                sec : int;
                ms : int;
                us : int;
              }
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            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 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 = Core.Span.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
          val compare : t -> t -> int
          val comparator : (t, comparator) Core_kernel.Comparator.t_
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> 'a -> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('a -> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val filter :
                    'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                  val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                  val compare_direct :
                    ('a -> 'a -> int) -> 'a t -> 'a t -> int
                  val equal : ('a -> 'a -> 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) ->
                    'a Core_kernel.Validate.check ->
                    'a t Core_kernel.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('a -> 'a -> bool) ->
                    (Key.t *
                     [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                    list
                  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:('a -> bool) -> bool
                  val exists : 'a t -> f:('a -> bool) -> bool
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                end
              type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a Tree.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'b ->
                    f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
                    'b
                  val fold_right :
                    t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel.Core_set.Tree.t ->
                    f:('a -> Elt.t option) -> t
                  val of_tree : 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) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val validate_positive : t Core_kernel.Validate.check
          val validate_non_negative : t Core_kernel.Validate.check
          val validate_negative : t Core_kernel.Validate.check
          val validate_non_positive : t Core_kernel.Validate.check
          val is_positive : t -> bool
          val is_non_negative : t -> bool
          val is_negative : t -> bool
          val is_non_positive : t -> bool
          val of_float : float -> t
          val to_float : t -> float
          module Hashable : sig type t = t end
          val hash : t -> int
          val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Pooled_hashtbl :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type 'a hash_set = 'a Core_kernel.Hash_set.t
              type t = elt hash_set
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, 'a elt_ list -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val hash : t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              type 'a t = 'a Core.Span.Hash_queue.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('a -> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
              val exists : 'a t -> f:('a -> bool) -> bool
              val for_all : 'a t -> f:('a -> bool) -> bool
              val count : 'a t -> f:('a -> bool) -> int
              val find : 'a t -> f:('a -> bool) -> 'a option
              val find_map : 'a t -> f:('a -> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val invariant : 'a t -> unit
              val create : unit -> 'a t
              val clear : 'a t -> unit
              val mem : 'a t -> Key.t -> bool
              val lookup : 'a t -> Key.t -> 'a option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
              val enqueue_exn : 'a t -> Key.t -> 'a -> unit
              val first : 'a t -> 'a option
              val keys : 'a t -> Key.t list
              val dequeue : 'a t -> 'a option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key : 'a t -> (Key.t * 'a) option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all : 'a t -> f:('a -> unit) -> unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> unit
              val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
              val replace_exn : 'a t -> Key.t -> 'a -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
              val foldi :
                'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
            end
          val pp : Format.formatter -> t -> unit
          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 robustly_compare : t -> t -> int
          val to_string : t -> string
          val of_string : string -> t
          val nanosecond : t
          val microsecond : t
          val millisecond : t
          val second : t
          val minute : t
          val hour : t
          val day : t
          val epsilon : t
          val zero : t
          val create :
            ?sign:Core_kernel.Std.Float.Sign.t ->
            ?day:int ->
            ?hr:int ->
            ?min:int -> ?sec:int -> ?ms:int -> ?us:int -> unit -> t
          val to_parts : t -> Parts.t
          val of_ns : float -> t
          val of_us : float -> t
          val of_ms : float -> t
          val of_sec : float -> t
          val of_int_sec : int -> t
          val of_min : float -> t
          val of_hr : float -> t
          val of_day : float -> t
          val to_ns : t -> float
          val to_us : t -> float
          val to_ms : t -> float
          val to_sec : t -> float
          val to_min : t -> float
          val to_hr : t -> float
          val to_day : t -> float
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val abs : t -> t
          val neg : t -> t
          val scale : t -> float -> t
          val ( / ) : t -> float -> t
          val ( // ) : t -> t -> float
          val to_short_string : t -> string
          val randomize : t -> percent:float -> t
          module Stable :
            sig
              module V1 :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
            end
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
          val bin_read_t_ : t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write_ml.writer
          val bin_write_t_ : t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
        end
      module Ofday :
        sig
          type t = Core.Ofday.t
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val 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 = Core.Ofday.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
          val compare : t -> t -> int
          val comparator : (t, comparator) Core_kernel.Comparator.t_
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> 'a -> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('a -> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val filter :
                    'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                  val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                  val compare_direct :
                    ('a -> 'a -> int) -> 'a t -> 'a t -> int
                  val equal : ('a -> 'a -> 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) ->
                    'a Core_kernel.Validate.check ->
                    'a t Core_kernel.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('a -> 'a -> bool) ->
                    (Key.t *
                     [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                    list
                  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:('a -> bool) -> bool
                  val exists : 'a t -> f:('a -> bool) -> bool
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                end
              type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a Tree.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'b ->
                    f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
                    'b
                  val fold_right :
                    t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel.Core_set.Tree.t ->
                    f:('a -> Elt.t option) -> t
                  val of_tree : 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) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val validate_positive : t Core_kernel.Validate.check
          val validate_non_negative : t Core_kernel.Validate.check
          val validate_negative : t Core_kernel.Validate.check
          val validate_non_positive : t Core_kernel.Validate.check
          val is_positive : t -> bool
          val is_non_negative : t -> bool
          val is_negative : t -> bool
          val is_non_positive : t -> bool
          val of_float : float -> t
          val to_float : t -> float
          module Hashable : sig type t = t end
          val hash : t -> int
          val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Pooled_hashtbl :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type 'a hash_set = 'a Core_kernel.Hash_set.t
              type t = elt hash_set
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, 'a elt_ list -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val hash : t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              type 'a t = 'a Core.Ofday.Hash_queue.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('a -> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
              val exists : 'a t -> f:('a -> bool) -> bool
              val for_all : 'a t -> f:('a -> bool) -> bool
              val count : 'a t -> f:('a -> bool) -> int
              val find : 'a t -> f:('a -> bool) -> 'a option
              val find_map : 'a t -> f:('a -> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val invariant : 'a t -> unit
              val create : unit -> 'a t
              val clear : 'a t -> unit
              val mem : 'a t -> Key.t -> bool
              val lookup : 'a t -> Key.t -> 'a option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
              val enqueue_exn : 'a t -> Key.t -> 'a -> unit
              val first : 'a t -> 'a option
              val keys : 'a t -> Key.t list
              val dequeue : 'a t -> 'a option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key : 'a t -> (Key.t * 'a) option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all : 'a t -> f:('a -> unit) -> unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> unit
              val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
              val replace_exn : 'a t -> Key.t -> 'a -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
              val foldi :
                'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
            end
          val pp : Format.formatter -> t -> unit
          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 robustly_compare : t -> t -> int
          val of_string : string -> t
          val to_string : t -> string
          val create :
            ?hr:int ->
            ?min:int -> ?sec:int -> ?ms:int -> ?us:int -> unit -> t
          val to_parts : t -> Core.Span.Parts.t
          val start_of_day : t
          val end_of_day : t
          val to_span_since_start_of_day : t -> Core.Span.t
          val of_span_since_start_of_day : Core.Span.t -> t
          val add : t -> Core.Span.t -> t option
          val sub : t -> Core.Span.t -> t option
          val diff : t -> t -> Core.Span.t
          val small_diff : t -> t -> Core.Span.t
          val to_string_trimmed : t -> string
          val to_sec_string : t -> string
          val of_string_iso8601_extended :
            ?pos:int -> ?len:int -> string -> t
          val to_millisec_string : t -> string
          module Stable :
            sig
              module V1 :
                sig
                  type t = t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                end
            end
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
          val bin_read_t_ : t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write_ml.writer
          val bin_write_t_ : t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val now : unit -> Core.Ofday.t
        end
      module Date :
        sig
          type t =
            Core.Date.t = private {
            y : int;
            m : Core_kernel.Std.Month.t;
            d : int;
          }
          module Hashable : sig type t = t end
          val hash : t -> int
          val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Pooled_hashtbl :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
              type 'b t = (key, 'b) hashtbl
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
              val create :
                ('a key_, unit -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                ('a key_,
                 ('a key_ * 'b) list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 'r list ->
                 [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val group :
                ('a key_,
                 get_key:('r -> 'a key_) ->
                 get_data:('r -> 'b) ->
                 combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
                Core_kernel.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
              val clear : ('a, 'b) t_ -> unit
              val copy : ('a, 'b) t_ -> ('a, 'b) t_
              val invariant : ('a, 'b) t_ -> unit
              val fold :
                ('a, 'b) t_ ->
                init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
              val iter :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
              val existsi :
                ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
              val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
              val length : ('a, 'b) t_ -> int
              val is_empty : ('a, 'b) t_ -> bool
              val mem : ('a, 'b) t_ -> 'a key_ -> bool
              val remove : ('a, 'b) t_ -> 'a key_ -> unit
              val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
              val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val add :
                ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
              val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
              val change :
                ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
              val add_multi :
                ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
              val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
              val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
              val mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
              val filter_map :
                ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
              val filter_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
              val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
              val filteri :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
              val partition_map :
                ('a, 'b) t_ ->
                f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_mapi :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                ('a, 'c) t_ * ('a, 'd) t_
              val partition_tf :
                ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
              val partitioni_tf :
                ('a, 'b) t_ ->
                f:(key:'a key_ -> data:'b -> bool) ->
                ('a, 'b) t_ * ('a, 'b) t_
              val find_or_add :
                ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
              val find : ('a, 'b) t_ -> 'a key_ -> 'b option
              val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
              val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
              val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
              val merge :
                ('k, 'a) t_ ->
                ('k, 'b) t_ ->
                f:(key:'k key_ ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                ('k, 'c) t_
              val merge_into :
                f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
                src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
              val keys : ('a, 'b) t_ -> 'a key_ list
              val data : ('a, 'b) t_ -> 'b list
              val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
              val filteri_inplace :
                ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
              val equal :
                ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
              val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
              val validate :
                name:('a key_ -> string) ->
                'b Core_kernel.Validate.check ->
                ('a, 'b) t_ Core_kernel.Validate.check
              val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
              val sexp_of_t :
                ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type 'a hash_set = 'a Core_kernel.Hash_set.t
              type t = elt hash_set
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, 'a elt_ list -> 'a t_)
                Core_kernel.Hash_set_intf.create_options_without_hashable
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val hash : t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              type 'a t = 'a Core.Date.Hash_queue.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('a -> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
              val exists : 'a t -> f:('a -> bool) -> bool
              val for_all : 'a t -> f:('a -> bool) -> bool
              val count : 'a t -> f:('a -> bool) -> int
              val find : 'a t -> f:('a -> bool) -> 'a option
              val find_map : 'a t -> f:('a -> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val invariant : 'a t -> unit
              val create : unit -> 'a t
              val clear : 'a t -> unit
              val mem : 'a t -> Key.t -> bool
              val lookup : 'a t -> Key.t -> 'a option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
              val enqueue_exn : 'a t -> Key.t -> 'a -> unit
              val first : 'a t -> 'a option
              val keys : 'a t -> Key.t list
              val dequeue : 'a t -> 'a option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key : 'a t -> (Key.t * 'a) option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all : 'a t -> f:('a -> unit) -> unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> unit
              val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
              val replace_exn : 'a t -> Key.t -> 'a -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
              val foldi :
                'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
            end
          val of_string : string -> t
          val to_string : t -> string
          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 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 = Core.Date.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
          val compare : t -> t -> int
          val comparator : (t, comparator) Core_kernel.Comparator.t_
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> 'a -> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('a -> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val filter :
                    'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                  val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                  val compare_direct :
                    ('a -> 'a -> int) -> 'a t -> 'a t -> int
                  val equal : ('a -> 'a -> 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) ->
                    'a Core_kernel.Validate.check ->
                    'a t Core_kernel.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('a -> 'a -> bool) ->
                    (Key.t *
                     [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                    list
                  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:('a -> bool) -> bool
                  val exists : 'a t -> f:('a -> bool) -> bool
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val next_key : 'a t -> Key.t -> (Key.t * 'a) option
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                end
              type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a Tree.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
              val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
              val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_read_t__ :
                ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator = comparator
                  val comparator : (t, comparator) Core_kernel.Comparator.t_
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'b ->
                    f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
                    'b
                  val fold_right :
                    t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel.Core_set.Tree.t ->
                    f:('a -> Elt.t option) -> t
                  val of_tree : 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) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Map_to_safe.writer
              val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
              val bin_read_t : t Bin_prot.Read_ml.reader
              val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val pp : Format.formatter -> t -> unit
          val create_exn : y:int -> m:Core_kernel.Std.Month.t -> d:int -> t
          val of_tm : Core.Core_unix.tm -> t
          val of_string_iso8601_basic : string -> pos:int -> t
          val to_string_iso8601_basic : t -> string
          val to_string_american : t -> string
          val day : t -> int
          val month : t -> Core_kernel.Std.Month.t
          val year : t -> int
          val day_of_week : t -> Core_kernel.Std.Day_of_week.t
          val is_weekend : t -> bool
          val is_weekday : t -> bool
          val is_business_day : t -> is_holiday:(t -> bool) -> bool
          val add_days : t -> int -> t
          val add_months : t -> int -> t
          val diff : t -> t -> int
          val add_weekdays : t -> int -> t
          val add_business_days : t -> is_holiday:(t -> bool) -> int -> t
          val dates_between : min:t -> max:t -> t list
          val business_dates_between :
            min:t -> max:t -> is_holiday:(t -> bool) -> t list
          val weekdays_between : min:t -> max:t -> t list
          val previous_weekday : t -> t
          val following_weekday : t -> t
          val first_strictly_after :
            t -> on:Core_kernel.Std.Day_of_week.t -> t
          module Export :
            sig
              type _date =
                t = private {
                y : int;
                m : Core_kernel.Std.Month.t;
                d : int;
              }
            end
          module Stable :
            sig
              module V1 :
                sig
                  type t = t
                  val compare : t -> t -> int
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
                  val bin_read_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    t Core_kernel.Std.Bin_prot.Write_ml.writer
                  val bin_write_t_ :
                    t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
            end
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
          val bin_read_t_ : t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write_ml.writer
          val bin_write_t_ : t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val of_time : Core.Time.t -> Core.Date.t
          val today : unit -> Core.Date.t
          val format : Core.Date.t -> string -> string
        end
      type t = Core.Time_internal.T.t
      module Hashable : sig type t = t end
      val hash : t -> int
      val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
      module Table :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Pooled_hashtbl :
        sig
          type key = t
          type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
          type 'b t = (key, 'b) hashtbl
          type ('a, 'b) t_ = 'b t
          type 'a key_ = key
          val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
          val create :
            ('a key_, unit -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_report_all_dups :
            ('a key_,
             ('a key_ * 'b) list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_exn :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val of_alist_multi :
            ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_mapped :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key :
            ('a key_,
             get_key:('r -> 'a key_) ->
             'r list ->
             [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val create_with_key_exn :
            ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val group :
            ('a key_,
             get_key:('r -> 'a key_) ->
             get_data:('r -> 'b) ->
             combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
            Core_kernel.Core_hashtbl_intf.create_options_without_hashable
          val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
          val clear : ('a, 'b) t_ -> unit
          val copy : ('a, 'b) t_ -> ('a, 'b) t_
          val invariant : ('a, 'b) t_ -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
          val iter :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
          val existsi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
          val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val mem : ('a, 'b) t_ -> 'a key_ -> bool
          val remove : ('a, 'b) t_ -> 'a key_ -> unit
          val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
          val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val add :
            ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
          val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
          val change :
            ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
          val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
          val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
          val map : ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_
          val mapi :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_
          val filter_map : ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_
          val filter_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_
          val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
          val filteri :
            ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
          val partition_map :
            ('a, 'b) t_ ->
            f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_mapi :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
            ('a, 'c) t_ * ('a, 'd) t_
          val partition_tf :
            ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val partitioni_tf :
            ('a, 'b) t_ ->
            f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
          val find_or_add :
            ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
          val find : ('a, 'b) t_ -> 'a key_ -> 'b option
          val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
          val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
          val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
          val merge :
            ('k, 'a) t_ ->
            ('k, 'b) t_ ->
            f:(key:'k key_ ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t_
          val merge_into :
            f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
            src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
          val keys : ('a, 'b) t_ -> 'a key_ list
          val data : ('a, 'b) t_ -> 'b list
          val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
          val filteri_inplace :
            ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
          val equal :
            ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
          val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
          val validate :
            name:('a key_ -> string) ->
            'b Core_kernel.Validate.check ->
            ('a, 'b) t_ Core_kernel.Validate.check
          val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
          val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
          val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Hash_set :
        sig
          type elt = t
          type 'a hash_set = 'a Core_kernel.Hash_set.t
          type t = elt hash_set
          type 'a t_ = t
          type 'a elt_ = elt
          val create :
            ('a, unit -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val of_list :
            ('a, 'a elt_ list -> 'a t_)
            Core_kernel.Hash_set_intf.create_options_without_hashable
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val hash : t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type 'a t = 'a Core.Time.Hash_queue.t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('a -> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
          val exists : 'a t -> f:('a -> bool) -> bool
          val for_all : 'a t -> f:('a -> bool) -> bool
          val count : 'a t -> f:('a -> bool) -> int
          val find : 'a t -> f:('a -> bool) -> 'a option
          val find_map : 'a t -> f:('a -> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> 'a -> unit
          val first : 'a t -> 'a option
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('a -> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> 'a -> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val foldi :
            'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
        end
      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 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 = Core.Time.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
      val compare : t -> t -> int
      val comparator : (t, comparator) Core_kernel.Comparator.t_
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> 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) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              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:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a 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:'b -> f:('b -> 'a -> 'b) -> 'b 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 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 -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> 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) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          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:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
          val bin_write_t : ('a, 'a t) Bin_prot.Map_to_safe.writer1
          val bin_write_t_ : ('a, 'a t) Bin_prot.Unsafe_write_c.writer1
          val bin_read_t : ('a, 'a t) Bin_prot.Map_to_safe.reader1
          val bin_read_t_ : ('a, 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_read_t__ : ('a, int -> 'a t) Bin_prot.Unsafe_read_c.reader1
          val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
          val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) 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 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 compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : 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) 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 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 compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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 * bool * 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 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:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Map_to_safe.writer
          val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
          val bin_read_t : t Bin_prot.Read_ml.reader
          val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
          val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
        end
      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 robustly_compare : t -> t -> int
      val of_float : float -> t
      val to_float : t -> float
      val pp : Format.formatter -> t -> unit
      val of_string : string -> t
      val to_string : t -> string
      val epoch : t
      val add : t -> Core.Span.t -> t
      val sub : t -> Core.Span.t -> t
      val diff : t -> t -> Core.Span.t
      val abs_diff : t -> t -> Core.Span.t
      val of_date_ofday : Core.Zone.t -> Core.Date.t -> Core.Ofday.t -> t
      val to_date_ofday : t -> Core.Zone.t -> Core.Date.t * Core.Ofday.t
      val to_date : t -> Core.Zone.t -> Core.Date.t
      val to_ofday : t -> Core.Zone.t -> Core.Ofday.t
      val of_local_date_ofday : Core.Date.t -> Core.Ofday.t -> t
      val to_local_date_ofday : t -> Core.Date.t * Core.Ofday.t
      val to_local_date : t -> Core.Date.t
      val to_local_ofday : t -> Core.Ofday.t
      val convert :
        from_tz:Core.Zone.t ->
        to_tz:Core.Zone.t ->
        Core.Date.t -> Core.Ofday.t -> Core.Date.t * Core.Ofday.t
      val utc_offset : ?zone:Core.Zone.t -> t -> Core.Span.t
      val to_filename_string : t -> string
      val of_filename_string : string -> t
      val to_string_fix_proto : [ `Local | `Utc ] -> t -> string
      val of_string_fix_proto : [ `Local | `Utc ] -> string -> t
      val to_string_trimmed : t -> string
      val to_sec_string : t -> string
      val of_localized_string : Core.Zone.t -> string -> t
      val to_string_abs : ?zone:Core.Zone.t -> t -> string
      val of_string_abs : string -> t
      val t_of_sexp_abs : Core_kernel.Std.Sexp.t -> t
      val now : unit -> t
      val pause : Core.Span.t -> unit
      val interruptible_pause :
        Core.Span.t -> [ `Ok | `Remaining of Core.Span.t ]
      val pause_forever : unit -> Core_kernel.Std.never_returns
      val occurrence :
        [ `First_after_or_at | `Last_before_or_at ] ->
        t -> ofday:Core.Ofday.t -> zone:Core.Zone.t -> t
      val format : t -> string -> string
      val to_epoch : t -> float
      val next_multiple : base:t -> after:t -> interval:Core.Span.t -> t
      module Stable :
        sig
          module V1 :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
              val bin_read_t_ :
                t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
              val bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write_ml.writer
              val bin_write_t_ :
                t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
            end
        end
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core_kernel.Std.Bin_prot.Read_ml.reader
      val bin_read_t_ : t Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        (int -> t) Core_kernel.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core_kernel.Std.Bin_prot.Write_ml.writer
      val bin_write_t_ : t Core_kernel.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
    end
  val try_finally_exn : fend:('a -> unit) -> ('a -> 'b) -> 'a -> 'b
  val open_out_safe : string -> Pervasives.out_channel
  module Url :
    sig
      val escape : string -> string
      val unescape :
        string ->
        error:(string -> 'error) ->
        (string, 'error) Biocaml_internal_pervasives.Result.t
    end
  module Parse :
    sig
      val escapable_string :
        string -> stop_before:char list -> string * char option * string
    end
  module Order :
    sig
      val compose :
        ('a -> 'b -> int option) ->
        ('a -> 'b -> int option) -> 'a -> 'b -> int
      val reverse : ('a -> 'b -> int) -> 'a -> 'b -> int
      val reversep :
        ('a -> 'b -> int Biocaml_internal_pervasives.Option.t) ->
        'a -> 'b -> int Biocaml_internal_pervasives.Option.t
      val totalify : ('a -> 'b -> 'c option) -> 'a -> 'b -> 'c
    end
  module Debug :
    sig
      val enable : string -> unit
      val disable : string -> unit
      val make : string -> ('a, unit, string, unit) Pervasives.format4 -> 'a
    end
end