sig
  module type S1 = Interval_intf.S1
  type 'a t = 'a 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 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 = 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 = 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 = 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 = 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 = 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 = 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 = Interval.Time.t
      type bound = 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 = 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:Zone.t -> Ofday.t * Ofday.t -> now:Time.t -> t
      val create_ending_before :
        ?zone:Zone.t -> Ofday.t * Ofday.t -> ubound:Time.t -> t
    end
  module Ofday :
    sig
      type t = Interval.Ofday.t
      type bound = 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 = 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