sig
  type t = Sexplib.Sexp.t = Atom of string | List of t list
  module O :
    sig type sexp = Sexplib.Sexp.t = Atom of string | List of t list end
  val ( >= ) : t -> t -> bool
  val ( <= ) : t -> t -> bool
  val ( = ) : t -> t -> bool
  val ( > ) : t -> t -> bool
  val ( < ) : t -> t -> bool
  val ( <> ) : t -> t -> bool
  val equal : t -> t -> bool
  val compare : t -> t -> int
  val min : t -> t -> t
  val max : t -> t -> t
  val ascending : t -> t -> int
  val descending : t -> t -> int
  val between : t -> low:t -> high:t -> bool
  module Replace_polymorphic_compare :
    sig
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val _squelch_unused_module_warning_ : unit
    end
  type comparator = Sexp.comparator
  val comparator : (t, comparator) 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) Comparator.t_
        end
      type ('a, 'b, 'c) map = ('a, 'b, 'c) Map.t
      type ('a, 'b, 'c) tree = ('a, 'b, 'c) Map.tree
      type 'v t = (Key.t, 'v, Key.comparator) map
      type ('k, 'v, 'comparator) t_ = 'v t
      type 'a key_ = Key.t
      type ('a, 'b, 'c) options =
          ('a, 'b, 'c) Core_map_intf.without_comparator
      val empty :
        ('k, 'comparator, ('k, 'a, 'comparator) t_)
        Core_map_intf.without_comparator
      val singleton :
        ('k, 'comparator, 'k key_ -> 'v -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val of_sorted_array :
        ('k, 'comparator,
         ('k key_ * 'v) array -> ('k, 'v, 'comparator) t_ Or_error.t)
        Core_map_intf.without_comparator
      val of_sorted_array_unchecked :
        ('k, 'comparator, ('k key_ * 'v) array -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val of_alist :
        ('k, 'comparator,
         ('k key_ * 'v) list ->
         [ `Duplicate_key of 'k key_ | `Ok of ('k, 'v, 'comparator) t_ ])
        Core_map_intf.without_comparator
      val of_alist_exn :
        ('k, 'comparator, ('k key_ * 'v) list -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val of_alist_multi :
        ('k, 'comparator,
         ('k key_ * 'v) list -> ('k, 'v list, 'comparator) t_)
        Core_map_intf.without_comparator
      val of_alist_fold :
        ('k, 'comparator,
         ('k key_ * 'v1) list ->
         init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_)
        Core_map_intf.without_comparator
      val of_tree :
        ('k, 'comparator,
         ('k key_, 'v, 'comparator) tree -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val invariants :
        ('k, 'comparator, ('k, 'v, 'comparator) t_ -> bool)
        Core_map_intf.without_comparator
      val is_empty : ('a, 'b, 'c) t_ -> bool
      val length : ('a, 'b, 'c) t_ -> int
      val add :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ ->
         key:'k key_ -> data:'v -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val add_multi :
        ('k, 'comparator,
         ('k, 'v list, 'comparator) t_ ->
         key:'k key_ -> data:'v -> ('k, 'v list, 'comparator) t_)
        Core_map_intf.without_comparator
      val change :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ ->
         'k key_ -> ('v option -> 'v option) -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val find :
        ('k, 'comparator, ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v option)
        Core_map_intf.without_comparator
      val find_exn :
        ('k, 'comparator, ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v)
        Core_map_intf.without_comparator
      val remove :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val mem :
        ('k, 'comparator, ('k, 'a, 'comparator) t_ -> 'k key_ -> bool)
        Core_map_intf.without_comparator
      val iter :
        ('k, 'v, 'a) t_ -> f:(key:'k key_ -> data:'v -> unit) -> unit
      val iter2 :
        ('k, 'comparator,
         ('k, 'v1, 'comparator) t_ ->
         ('k, 'v2, 'comparator) t_ ->
         f:(key:'k key_ ->
            data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
            unit) ->
         unit)
        Core_map_intf.without_comparator
      val map :
        ('k, 'v1, 'comparator) t_ ->
        f:('v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
      val mapi :
        ('k, 'v1, 'comparator) t_ ->
        f:(key:'k key_ -> data:'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
      val fold :
        ('k, 'v, 'b) t_ ->
        init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
      val fold_right :
        ('k, 'v, 'b) t_ ->
        init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
      val filter :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ ->
         f:(key:'k key_ -> data:'v -> bool) -> ('k, 'v, 'comparator) t_)
        Core_map_intf.without_comparator
      val filter_map :
        ('k, 'comparator,
         ('k, 'v1, 'comparator) t_ ->
         f:('v1 -> 'v2 option) -> ('k, 'v2, 'comparator) t_)
        Core_map_intf.without_comparator
      val filter_mapi :
        ('k, 'comparator,
         ('k, 'v1, 'comparator) t_ ->
         f:(key:'k key_ -> data:'v1 -> 'v2 option) ->
         ('k, 'v2, 'comparator) t_)
        Core_map_intf.without_comparator
      val compare_direct :
        ('k, 'comparator,
         ('v -> 'v -> int) ->
         ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> int)
        Core_map_intf.without_comparator
      val equal :
        ('k, 'comparator,
         ('v -> 'v -> bool) ->
         ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> bool)
        Core_map_intf.without_comparator
      val keys : ('k, 'a, 'b) t_ -> 'k key_ list
      val data : ('a, 'v, 'b) t_ -> 'v list
      val to_alist : ('k, 'v, 'a) t_ -> ('k key_ * 'v) list
      val merge :
        ('k, 'comparator,
         ('k, 'v1, 'comparator) t_ ->
         ('k, 'v2, 'comparator) t_ ->
         f:(key:'k key_ ->
            [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
            'v3 option) ->
         ('k, 'v3, 'comparator) t_)
        Core_map_intf.without_comparator
      val symmetric_diff :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ ->
         ('k, 'v, 'comparator) t_ ->
         data_equal:('v -> 'v -> bool) ->
         ('k key_ * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ])
         list)
        Core_map_intf.without_comparator
      val min_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
      val min_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
      val max_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
      val max_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * '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, 'comparator,
         ('k, 'v, 'comparator) t_ ->
         min:'k key_ ->
         max:'k key_ ->
         init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a)
        Core_map_intf.without_comparator
      val range_to_alist :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ ->
         min:'k key_ -> max:'k key_ -> ('k key_ * 'v) list)
        Core_map_intf.without_comparator
      val prev_key :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
        Core_map_intf.without_comparator
      val next_key :
        ('k, 'comparator,
         ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
        Core_map_intf.without_comparator
      val rank :
        ('k, 'comparator, ('k, 'v, 'comparator) t_ -> 'k key_ -> int option)
        Core_map_intf.without_comparator
      val to_tree :
        ('k, 'v, 'comparator) t_ -> ('k key_, 'v, 'comparator) tree
      module Tree :
        sig
          type 'v t = (Key.t, 'v, Key.comparator) tree
          type ('k, 'v, 'c) t_ = 'v t
          val empty :
            ('k, 'comparator, ('k, 'a, 'comparator) t_)
            Core_map_intf.without_comparator
          val singleton :
            ('k, 'comparator, 'k key_ -> 'v -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val of_sorted_array :
            ('k, 'comparator,
             ('k key_ * 'v) array -> ('k, 'v, 'comparator) t_ Or_error.t)
            Core_map_intf.without_comparator
          val of_sorted_array_unchecked :
            ('k, 'comparator,
             ('k key_ * 'v) array -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val of_alist :
            ('k, 'comparator,
             ('k key_ * 'v) list ->
             [ `Duplicate_key of 'k key_ | `Ok of ('k, 'v, 'comparator) t_ ])
            Core_map_intf.without_comparator
          val of_alist_exn :
            ('k, 'comparator,
             ('k key_ * 'v) list -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val of_alist_multi :
            ('k, 'comparator,
             ('k key_ * 'v) list -> ('k, 'v list, 'comparator) t_)
            Core_map_intf.without_comparator
          val of_alist_fold :
            ('k, 'comparator,
             ('k key_ * 'v1) list ->
             init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_)
            Core_map_intf.without_comparator
          val of_tree :
            ('k, 'comparator,
             ('k key_, 'v, 'comparator) tree -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val invariants :
            ('k, 'comparator, ('k, 'v, 'comparator) t_ -> bool)
            Core_map_intf.without_comparator
          val is_empty : ('a, 'b, 'c) t_ -> bool
          val length : ('a, 'b, 'c) t_ -> int
          val add :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             key:'k key_ -> data:'v -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val add_multi :
            ('k, 'comparator,
             ('k, 'v list, 'comparator) t_ ->
             key:'k key_ -> data:'v -> ('k, 'v list, 'comparator) t_)
            Core_map_intf.without_comparator
          val change :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             'k key_ -> ('v option -> 'v option) -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val find :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v option)
            Core_map_intf.without_comparator
          val find_exn :
            ('k, 'comparator, ('k, 'v, 'comparator) t_ -> 'k key_ -> 'v)
            Core_map_intf.without_comparator
          val remove :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val mem :
            ('k, 'comparator, ('k, 'a, 'comparator) t_ -> 'k key_ -> bool)
            Core_map_intf.without_comparator
          val iter :
            ('k, 'v, 'a) t_ -> f:(key:'k key_ -> data:'v -> unit) -> unit
          val iter2 :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             ('k, 'v2, 'comparator) t_ ->
             f:(key:'k key_ ->
                data:[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
                unit) ->
             unit)
            Core_map_intf.without_comparator
          val map :
            ('k, 'v1, 'comparator) t_ ->
            f:('v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
          val mapi :
            ('k, 'v1, 'comparator) t_ ->
            f:(key:'k key_ -> data:'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
          val fold :
            ('k, 'v, 'b) t_ ->
            init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
          val fold_right :
            ('k, 'v, 'b) t_ ->
            init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
          val filter :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             f:(key:'k key_ -> data:'v -> bool) -> ('k, 'v, 'comparator) t_)
            Core_map_intf.without_comparator
          val filter_map :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             f:('v1 -> 'v2 option) -> ('k, 'v2, 'comparator) t_)
            Core_map_intf.without_comparator
          val filter_mapi :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             f:(key:'k key_ -> data:'v1 -> 'v2 option) ->
             ('k, 'v2, 'comparator) t_)
            Core_map_intf.without_comparator
          val compare_direct :
            ('k, 'comparator,
             ('v -> 'v -> int) ->
             ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> int)
            Core_map_intf.without_comparator
          val equal :
            ('k, 'comparator,
             ('v -> 'v -> bool) ->
             ('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> bool)
            Core_map_intf.without_comparator
          val keys : ('k, 'a, 'b) t_ -> 'k key_ list
          val data : ('a, 'v, 'b) t_ -> 'v list
          val to_alist : ('k, 'v, 'a) t_ -> ('k key_ * 'v) list
          val merge :
            ('k, 'comparator,
             ('k, 'v1, 'comparator) t_ ->
             ('k, 'v2, 'comparator) t_ ->
             f:(key:'k key_ ->
                [ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] ->
                'v3 option) ->
             ('k, 'v3, 'comparator) t_)
            Core_map_intf.without_comparator
          val symmetric_diff :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             ('k, 'v, 'comparator) t_ ->
             data_equal:('v -> 'v -> bool) ->
             ('k key_ * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ])
             list)
            Core_map_intf.without_comparator
          val min_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
          val min_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
          val max_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
          val max_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * '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, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             min:'k key_ ->
             max:'k key_ ->
             init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a)
            Core_map_intf.without_comparator
          val range_to_alist :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ ->
             min:'k key_ -> max:'k key_ -> ('k key_ * 'v) list)
            Core_map_intf.without_comparator
          val prev_key :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
            Core_map_intf.without_comparator
          val next_key :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> ('k key_ * 'v) option)
            Core_map_intf.without_comparator
          val rank :
            ('k, 'comparator,
             ('k, 'v, 'comparator) t_ -> 'k key_ -> int option)
            Core_map_intf.without_comparator
          val to_tree :
            ('k, 'v, 'comparator) t_ -> ('k key_, 'v, 'comparator) tree
          val t_of_sexp : (Sexplib.Sexp.t -> 'v) -> Sexplib.Sexp.t -> 'v t
          val sexp_of_t : ('v -> Sexplib.Sexp.t) -> 'v t -> Sexplib.Sexp.t
        end
      val compare : ('v -> 'v -> int) -> 'v t -> 'v t -> int
      val t_of_sexp : (Sexplib.Sexp.t -> 'v) -> Sexplib.Sexp.t -> 'v t
      val sexp_of_t : ('v -> Sexplib.Sexp.t) -> 'v t -> Sexplib.Sexp.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) Comparator.t_
        end
      type ('a, 'b) set = ('a, 'b) Set.t
      type ('a, 'b) tree = ('a, 'b) Set.tree
      type t = (Elt.t, Elt.comparator) set
      type ('a, 'comparator) t_ = t
      type 'a elt_ = Elt.t
      val singleton :
        ('a, 'comparator, 'a elt_ -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val union_list :
        ('a, 'comparator, ('a, 'comparator) t_ list -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val of_list :
        ('a, 'comparator, 'a elt_ list -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val of_array :
        ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val of_sorted_array :
        ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_ Or_error.t)
        Core_set_intf.without_comparator
      val of_sorted_array_unchecked :
        ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val stable_dedup_list :
        ('a, 'b, 'a elt_ list -> 'a elt_ list)
        Core_set_intf.without_comparator
      val map :
        ('b, 'comparator,
         ('a, 'c) set -> f:('a -> 'b elt_) -> ('b, 'comparator) t_)
        Core_set_intf.without_comparator
      val filter_map :
        ('b, 'comparator,
         ('a, 'c) set -> f:('a -> 'b elt_ option) -> ('b, 'comparator) t_)
        Core_set_intf.without_comparator
      val of_tree :
        ('a, 'comparator,
         ('a elt_, 'comparator) tree -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val length : ('a, 'b) t_ -> int
      val is_empty : ('a, 'b) t_ -> bool
      val iter : ('a, 'b) t_ -> f:('a elt_ -> unit) -> unit
      val fold :
        ('a, 'b) t_ ->
        init:'accum -> f:('accum -> 'a elt_ -> 'accum) -> 'accum
      val exists : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
      val for_all : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
      val count : ('a, 'b) t_ -> f:('a elt_ -> bool) -> int
      val find : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_ option
      val find_map : ('a, 'c) t_ -> f:('a elt_ -> 'b option) -> 'b option
      val to_list : ('a, 'b) t_ -> 'a elt_ list
      val to_array : ('a, 'b) t_ -> 'a elt_ array
      val invariants :
        ('a, 'comparator, ('a, 'comparator) t_ -> bool)
        Core_set_intf.without_comparator
      val mem :
        ('a, 'comparator, ('a, 'comparator) t_ -> 'a elt_ -> bool)
        Core_set_intf.without_comparator
      val add :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val remove :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val union :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val inter :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val diff :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val compare_direct :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> int)
        Core_set_intf.without_comparator
      val equal :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
        Core_set_intf.without_comparator
      val subset :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
        Core_set_intf.without_comparator
      val fold_until :
        ('a, 'c) t_ ->
        init:'b ->
        f:('b -> 'a elt_ -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
      val fold_right :
        ('a, 'c) t_ -> init:'b -> f:('a elt_ -> 'b -> 'b) -> 'b
      val iter2 :
        ('a, 'comparator,
         ('a, 'comparator) t_ ->
         ('a, 'comparator) t_ ->
         f:([ `Both of 'a elt_ * 'a elt_
            | `Left of 'a elt_
            | `Right of 'a elt_ ] -> unit) ->
         unit)
        Core_set_intf.without_comparator
      val filter :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> f:('a elt_ -> bool) -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val partition_tf :
        ('a, 'comparator,
         ('a, 'comparator) t_ ->
         f:('a elt_ -> bool) -> ('a, 'comparator) t_ * ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val elements : ('a, 'b) t_ -> 'a elt_ list
      val min_elt : ('a, 'b) t_ -> 'a elt_ option
      val min_elt_exn : ('a, 'b) t_ -> 'a elt_
      val max_elt : ('a, 'b) t_ -> 'a elt_ option
      val max_elt_exn : ('a, 'b) t_ -> 'a elt_
      val choose : ('a, 'b) t_ -> 'a elt_ option
      val choose_exn : ('a, 'b) t_ -> 'a elt_
      val split :
        ('a, 'comparator,
         ('a, 'comparator) t_ ->
         'a elt_ -> ('a, 'comparator) t_ * bool * ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val group_by :
        ('a, 'comparator,
         ('a, 'comparator) t_ ->
         equiv:('a elt_ -> 'a elt_ -> bool) -> ('a, 'comparator) t_ list)
        Core_set_intf.without_comparator
      val find_exn : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_
      val find_index : ('a, 'b) t_ -> int -> 'a elt_ option
      val remove_index :
        ('a, 'comparator,
         ('a, 'comparator) t_ -> int -> ('a, 'comparator) t_)
        Core_set_intf.without_comparator
      val to_tree : ('a, 'comparator) t_ -> ('a elt_, 'comparator) tree
      val empty : t
      module Tree :
        sig
          type t = (Elt.t, Elt.comparator) tree
          type ('a, 'b) t_ = t
          val empty :
            ('a, 'comparator, ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val singleton :
            ('a, 'comparator, 'a elt_ -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val union_list :
            ('a, 'comparator,
             ('a, 'comparator) t_ list -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val of_list :
            ('a, 'comparator, 'a elt_ list -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val of_array :
            ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val of_sorted_array :
            ('a, 'comparator,
             'a elt_ array -> ('a, 'comparator) t_ Or_error.t)
            Core_set_intf.without_comparator
          val of_sorted_array_unchecked :
            ('a, 'comparator, 'a elt_ array -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val stable_dedup_list :
            ('a, 'b, 'a elt_ list -> 'a elt_ list)
            Core_set_intf.without_comparator
          val map :
            ('b, 'comparator,
             ('a, 'c) tree -> f:('a -> 'b elt_) -> ('b, 'comparator) t_)
            Core_set_intf.without_comparator
          val filter_map :
            ('b, 'comparator,
             ('a, 'c) tree ->
             f:('a -> 'b elt_ option) -> ('b, 'comparator) t_)
            Core_set_intf.without_comparator
          val of_tree :
            ('a, 'comparator,
             ('a elt_, 'comparator) tree -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val length : ('a, 'b) t_ -> int
          val is_empty : ('a, 'b) t_ -> bool
          val iter : ('a, 'b) t_ -> f:('a elt_ -> unit) -> unit
          val fold :
            ('a, 'b) t_ ->
            init:'accum -> f:('accum -> 'a elt_ -> 'accum) -> 'accum
          val exists : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
          val for_all : ('a, 'b) t_ -> f:('a elt_ -> bool) -> bool
          val count : ('a, 'b) t_ -> f:('a elt_ -> bool) -> int
          val find : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_ option
          val find_map : ('a, 'c) t_ -> f:('a elt_ -> 'b option) -> 'b option
          val to_list : ('a, 'b) t_ -> 'a elt_ list
          val to_array : ('a, 'b) t_ -> 'a elt_ array
          val invariants :
            ('a, 'comparator, ('a, 'comparator) t_ -> bool)
            Core_set_intf.without_comparator
          val mem :
            ('a, 'comparator, ('a, 'comparator) t_ -> 'a elt_ -> bool)
            Core_set_intf.without_comparator
          val add :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val remove :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> 'a elt_ -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val union :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val inter :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val diff :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val compare_direct :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> int)
            Core_set_intf.without_comparator
          val equal :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
            Core_set_intf.without_comparator
          val subset :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> ('a, 'comparator) t_ -> bool)
            Core_set_intf.without_comparator
          val fold_until :
            ('a, 'c) t_ ->
            init:'b ->
            f:('b -> 'a elt_ -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right :
            ('a, 'c) t_ -> init:'b -> f:('a elt_ -> 'b -> 'b) -> 'b
          val iter2 :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             ('a, 'comparator) t_ ->
             f:([ `Both of 'a elt_ * 'a elt_
                | `Left of 'a elt_
                | `Right of 'a elt_ ] -> unit) ->
             unit)
            Core_set_intf.without_comparator
          val filter :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             f:('a elt_ -> bool) -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val partition_tf :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             f:('a elt_ -> bool) ->
             ('a, 'comparator) t_ * ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val elements : ('a, 'b) t_ -> 'a elt_ list
          val min_elt : ('a, 'b) t_ -> 'a elt_ option
          val min_elt_exn : ('a, 'b) t_ -> 'a elt_
          val max_elt : ('a, 'b) t_ -> 'a elt_ option
          val max_elt_exn : ('a, 'b) t_ -> 'a elt_
          val choose : ('a, 'b) t_ -> 'a elt_ option
          val choose_exn : ('a, 'b) t_ -> 'a elt_
          val split :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             'a elt_ -> ('a, 'comparator) t_ * bool * ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val group_by :
            ('a, 'comparator,
             ('a, 'comparator) t_ ->
             equiv:('a elt_ -> 'a elt_ -> bool) -> ('a, 'comparator) t_ list)
            Core_set_intf.without_comparator
          val find_exn : ('a, 'b) t_ -> f:('a elt_ -> bool) -> 'a elt_
          val find_index : ('a, 'b) t_ -> int -> 'a elt_ option
          val remove_index :
            ('a, 'comparator,
             ('a, 'comparator) t_ -> int -> ('a, 'comparator) t_)
            Core_set_intf.without_comparator
          val to_tree : ('a, 'comparator) t_ -> ('a elt_, 'comparator) tree
          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 compare : t -> t -> int
    end
  type bigstring =
      (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
  val default_indent : int ref
  val size : t -> int * int
  val scan_sexp : ?buf:Buffer.t -> Lexing.lexbuf -> t
  val scan_sexps : ?buf:Buffer.t -> Lexing.lexbuf -> t list
  val scan_rev_sexps : ?buf:Buffer.t -> Lexing.lexbuf -> t list
  val scan_sexp_opt : ?buf:Buffer.t -> Lexing.lexbuf -> t option
  val scan_iter_sexps :
    ?buf:Buffer.t -> f:(t -> unit) -> Lexing.lexbuf -> unit
  val scan_fold_sexps :
    ?buf:Buffer.t -> f:('a -> t -> 'a) -> init:'a -> Lexing.lexbuf -> 'a
  val scan_sexps_conv :
    ?buf:Buffer.t -> f:(t -> 'a) -> Lexing.lexbuf -> 'a list
  module Parse_pos :
    sig
      type t =
        Sexplib.Pre_sexp.Parse_pos.t = private {
        mutable text_line : int;
        mutable text_char : int;
        mutable global_offset : int;
        mutable buf_pos : int;
      }
      val create :
        ?text_line:int ->
        ?text_char:int -> ?buf_pos:int -> ?global_offset:int -> unit -> t
      val with_buf_pos : t -> int -> t
    end
  module Cont_state :
    sig
      type t =
        Sexplib.Pre_sexp.Cont_state.t =
          Parsing_whitespace
        | Parsing_atom
        | Parsing_list
        | Parsing_sexp_comment
        | Parsing_block_comment
      val to_string : t -> string
    end
  type ('a, 't) parse_result =
    ('a, 't) Sexplib.Pre_sexp.parse_result =
      Done of 't * Parse_pos.t
    | Cont of Cont_state.t * ('a, 't) parse_fun
  and ('a, 't) parse_fun = pos:int -> len:int -> 'a -> ('a, 't) parse_result
  module Annotated :
    sig
      type pos =
        Sexplib.Pre_sexp.Annotated.pos = {
        line : int;
        col : int;
        offset : int;
      }
      type range =
        Sexplib.Pre_sexp.Annotated.range = {
        start_pos : pos;
        end_pos : pos;
      }
      type t =
        Sexplib.Pre_sexp.Annotated.t =
          Atom of range * Sexplib.Type.t
        | List of range * t list * Sexplib.Type.t
      type 'a conv = [ `Error of exn * t | `Result of 'a ]
      exception Conv_exn of string * exn
      type stack =
        Sexplib.Pre_sexp.Annotated.stack = {
        mutable positions : pos list;
        mutable stack : t list list;
      }
      val get_sexp : t -> Sexplib.Type.t
      val get_range : t -> range
      val find_sexp : t -> Sexplib.Type.t -> t option
      val parse :
        ?parse_pos:Parse_pos.t ->
        ?len:int -> string -> (string, t) parse_result
      val parse_bigstring :
        ?parse_pos:Parse_pos.t ->
        ?len:int -> bigstring -> (bigstring, t) parse_result
      val input_sexp : ?parse_pos:Parse_pos.t -> in_channel -> t
      val input_sexps :
        ?parse_pos:Parse_pos.t -> ?buf:string -> in_channel -> t list
      val input_rev_sexps :
        ?parse_pos:Parse_pos.t -> ?buf:string -> in_channel -> t list
      val load_sexp : ?strict:bool -> ?buf:string -> string -> t
      val load_sexps : ?buf:string -> string -> t list
      val load_rev_sexps : ?buf:string -> string -> t list
      val of_string : string -> t
      val of_bigstring : bigstring -> t
      val conv : (Sexplib.Type.t -> 'a) -> t -> 'a conv
      val get_conv_exn : file:string -> exc:exn -> t -> exn
    end
  type 't parse_state =
    't Sexplib.Pre_sexp.parse_state = private {
    parse_pos : Parse_pos.t;
    mutable pstack : 't;
    pbuf : Buffer.t;
  }
  type parse_error =
    Sexplib.Pre_sexp.parse_error = {
    location : string;
    err_msg : string;
    parse_state :
      [ `Annot of Annotated.stack parse_state
      | `Sexp of t list list parse_state ];
  }
  exception Parse_error of parse_error
  val parse :
    ?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, t) parse_result
  val parse_bigstring :
    ?parse_pos:Parse_pos.t ->
    ?len:int -> bigstring -> (bigstring, t) parse_result
  val input_sexp : ?parse_pos:Parse_pos.t -> in_channel -> t
  val input_sexps :
    ?parse_pos:Parse_pos.t -> ?buf:string -> in_channel -> t list
  val input_rev_sexps :
    ?parse_pos:Parse_pos.t -> ?buf:string -> in_channel -> t list
  val load_sexp : ?strict:bool -> ?buf:string -> string -> t
  val load_sexps : ?buf:string -> string -> t list
  val load_rev_sexps : ?buf:string -> string -> t list
  val load_sexp_conv :
    ?strict:bool -> ?buf:string -> string -> (t -> 'a) -> 'a Annotated.conv
  val load_sexp_conv_exn :
    ?strict:bool -> ?buf:string -> string -> (t -> 'a) -> 'a
  val load_sexps_conv :
    ?buf:string -> string -> (t -> 'a) -> 'a Annotated.conv list
  val load_sexps_conv_exn : ?buf:string -> string -> (t -> 'a) -> 'a list
  val output_hum : out_channel -> t -> unit
  val output_hum_indent : int -> out_channel -> t -> unit
  val output_mach : out_channel -> t -> unit
  val output : out_channel -> t -> unit
  val save_hum : ?perm:int -> string -> t -> unit
  val save_mach : ?perm:int -> string -> t -> unit
  val save : ?perm:int -> string -> t -> unit
  val save_sexps_hum : ?perm:int -> string -> t list -> unit
  val save_sexps_mach : ?perm:int -> string -> t list -> unit
  val save_sexps : ?perm:int -> string -> t list -> unit
  val pp_hum : Format.formatter -> t -> unit
  val pp_hum_indent : int -> Format.formatter -> t -> unit
  val pp_mach : Format.formatter -> t -> unit
  val pp : Format.formatter -> t -> unit
  module Of_string_conv_exn :
    sig
      type t =
        Sexp.Of_string_conv_exn.t = {
        exc : exn;
        sexp : Sexplib.Type.t;
        sub_sexp : Sexplib.Type.t;
      }
      exception E of t
    end
  val of_string : string -> t
  val of_string_conv : string -> (t -> 'a) -> 'a Annotated.conv
  val of_string_conv_exn : string -> (t -> 'a) -> 'a
  val of_bigstring : bigstring -> t
  val of_bigstring_conv : bigstring -> (t -> 'a) -> 'a Annotated.conv
  val of_bigstring_conv_exn : bigstring -> (t -> 'a) -> 'a
  val to_string_hum : ?indent:int -> t -> string
  val to_string_mach : t -> string
  val to_string : t -> string
  val to_buffer_hum : buf:Buffer.t -> ?indent:int -> t -> unit
  val to_buffer_mach : buf:Buffer.t -> t -> unit
  val to_buffer : buf:Buffer.t -> t -> unit
  val to_buffer_gen :
    buf:'buffer ->
    add_char:('buffer -> char -> unit) ->
    add_string:('buffer -> string -> unit) -> t -> unit
  val unit : t
  type found = [ `Found | `Pos of int * found ]
  type search_result = [ `Found | `Not_found | `Pos of int * found ]
  val search_physical : t -> contained:t -> search_result
  val subst_found : t -> subst:t -> found -> t
  module With_layout :
    sig
      type pos = Sexplib.Src_pos.Relative.t = { row : int; col : int; }
      val sexp_of_pos : pos -> Sexplib.Type.t
      type t =
        Sexp.With_layout.t =
          Atom of pos * string * string option
        | List of pos * t_or_comment list * pos
      and t_or_comment =
        Sexp.With_layout.t_or_comment =
          Sexp of t
        | Comment of comment
      and comment =
        Sexp.With_layout.comment =
          Plain_comment of pos * string
        | Sexp_comment of pos * comment list * t
      val sexp_of_t : t -> Sexplib.Type.t
      val sexp_of_comment : comment -> Sexplib.Type.t
      val sexp_of_t_or_comment : t_or_comment -> Sexplib.Type.t
      module Forget :
        sig
          val t : t -> Sexplib.Type.t
          val t_or_comment : t_or_comment -> Sexplib.Type.t option
          val t_or_comments : t_or_comment list -> Sexplib.Type.t list
        end
      module Render :
        sig
          type 'a t = 'a Sexp.With_layout.Render.t
          val return : 'a -> 'a t
          val bind : 'a t -> ('a -> 'b t) -> 'b t
          val sexp : t_or_comment -> unit t
          val run : (char -> unit) -> unit t -> unit
        end
      module Parser :
        sig
          type token = Sexp.With_layout.Parser.token
          val sexp :
            (Lexing.lexbuf -> token) -> Lexing.lexbuf -> t_or_comment
          val sexp_opt :
            (Lexing.lexbuf -> token) -> Lexing.lexbuf -> t_or_comment option
          val sexps :
            (Lexing.lexbuf -> token) -> Lexing.lexbuf -> t_or_comment list
          val rev_sexps :
            (Lexing.lexbuf -> token) -> Lexing.lexbuf -> t_or_comment list
          val sexps_abs :
            (Lexing.lexbuf -> token) ->
            Lexing.lexbuf ->
            Sexplib.Type_with_layout.Parsed.t_or_comment list
        end
      module Lexer :
        sig val main : ?buf:Buffer.t -> Lexing.lexbuf -> Parser.token end
    end
  exception Of_sexp_error of exn * t
  val of_int_style : [ `No_underscores | `Underscores ] ref
  type 'a no_raise = 'a
  module Sexp_option :
    sig
      type 'a t = 'a option
      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
  module Sexp_list :
    sig
      type 'a t = 'a list
      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
  module Sexp_array :
    sig
      type 'a t = 'a array
      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
  module Sexp_opaque :
    sig
      type 'a t = 'a
      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
  module Sexp_maybe :
    sig
      type 'a t = ('a, Sexplib.Sexp.t * Error.t) Result.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_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 -> 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 no_raise_of_sexp :
    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a no_raise
  val sexp_of_no_raise :
    ('a -> Sexplib.Sexp.t) -> 'a no_raise -> Sexplib.Sexp.t
  val bin_no_raise :
    'a Bin_prot.Type_class.t -> 'a no_raise Bin_prot.Type_class.t
  val bin_read_no_raise :
    'a Bin_prot.Unsafe_read_c.reader -> 'a no_raise Bin_prot.Read_ml.reader
  val bin_read_no_raise_ :
    'a Bin_prot.Unsafe_read_c.reader ->
    'a no_raise Bin_prot.Unsafe_read_c.reader
  val bin_read_no_raise__ :
    'a Bin_prot.Unsafe_read_c.reader ->
    (int -> 'a no_raise) Bin_prot.Unsafe_read_c.reader
  val bin_reader_no_raise :
    'a Bin_prot.Type_class.reader -> 'a no_raise Bin_prot.Type_class.reader
  val bin_size_no_raise :
    'a Bin_prot.Size.sizer -> 'a no_raise Bin_prot.Size.sizer
  val bin_write_no_raise :
    'a Bin_prot.Unsafe_write_c.writer -> 'a no_raise Bin_prot.Write_ml.writer
  val bin_write_no_raise_ :
    'a Bin_prot.Unsafe_write_c.writer ->
    'a no_raise Bin_prot.Unsafe_write_c.writer
  val bin_writer_no_raise :
    'a Bin_prot.Type_class.writer -> 'a no_raise Bin_prot.Type_class.writer
end