sig
  module Types :
    sig
      module Poly :
        sig
          module type Equatable =
            sig
              type 'a t
              val equal :
                'Reins.Types.Poly.Equatable.t ->
                'Reins.Types.Poly.Equatable.t -> bool
            end
          module type Comparable =
            sig
              type 'a t
              val compare :
                ('-> '-> int) ->
                'Reins.Types.Poly.Comparable.t ->
                'Reins.Types.Poly.Comparable.t -> int
              val to_string :
                ('-> string) -> 'Reins.Types.Poly.Comparable.t -> string
            end
          module type Hashable =
            sig
              type 'a t
              val equal : 'a t -> 'a t -> bool
              val hash : 'a t -> int
            end
          module type Arbitrary =
            sig
              type 'a t
              val gen :
                (?size:int -> Random.State.t -> 'a) ->
                ?size:int ->
                Random.State.t -> 'Reins.Types.Poly.Arbitrary.t
              val to_string :
                ('-> string) -> 'Reins.Types.Poly.Arbitrary.t -> string
            end
          module type ArbitraryComparable =
            sig
              type 'a t
              val gen :
                (?size:int -> Random.State.t -> 'a) ->
                ?size:int -> Random.State.t -> 'a t
              val to_string : ('-> string) -> 'a t -> string
              val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            end
          module ComposeComparable :
            functor (A : Comparable->
              functor (B : Comparable->
                sig
                  type 'a t = 'B.t A.t
                  val compare :
                    ('-> '-> int) ->
                    'Reins.Types.Poly.ComposeComparable.t ->
                    'Reins.Types.Poly.ComposeComparable.t -> int
                  val to_string :
                    ('-> string) ->
                    'Reins.Types.Poly.ComposeComparable.t -> string
                end
          module ComposeGen :
            functor (A : Arbitrary->
              functor (B : Arbitrary->
                sig
                  type 'a t = 'B.t A.t
                  val gen :
                    (?size:int -> Random.State.t -> 'a) ->
                    ?size:int ->
                    Random.State.t -> 'Reins.Types.Poly.ComposeGen.t
                  val to_string :
                    ('-> string) ->
                    'Reins.Types.Poly.ComposeGen.t -> string
                end
          module ComposeGenComparable :
            functor (A : ArbitraryComparable->
              functor (B : ArbitraryComparable->
                sig
                  type 'a t = 'B.t A.t
                  val gen :
                    (?size:int -> Random.State.t -> 'a) ->
                    ?size:int ->
                    Random.State.t ->
                    'Reins.Types.Poly.ComposeGenComparable.t
                  val to_string :
                    ('-> string) ->
                    'Reins.Types.Poly.ComposeGenComparable.t -> string
                  val compare :
                    ('-> '-> int) ->
                    'Reins.Types.Poly.ComposeGenComparable.t ->
                    'Reins.Types.Poly.ComposeGenComparable.t -> int
                end
          module Close :
            sig
              type 'a t = 'a
              val to_string : ('-> 'b) -> '-> 'b
              val compare : ('-> '-> 'c) -> '-> '-> 'c
            end
        end
      module Mono :
        sig
          module type Equatable =
            sig
              type t
              val equal :
                Reins.Types.Mono.Equatable.t ->
                Reins.Types.Mono.Equatable.t -> bool
            end
          module type Comparable =
            sig
              type t
              val compare :
                Reins.Types.Mono.Comparable.t ->
                Reins.Types.Mono.Comparable.t -> int
              val to_string : Reins.Types.Mono.Comparable.t -> string
            end
          module type Hashable =
            sig type t val equal : t -> t -> bool val hash : t -> int end
          module type Arbitrary =
            sig
              type t
              val gen :
                ?size:int -> Random.State.t -> Reins.Types.Mono.Arbitrary.t
              val to_string : Reins.Types.Mono.Arbitrary.t -> string
            end
          module type ArbitraryComparable =
            sig
              type t
              val gen : ?size:int -> Random.State.t -> t
              val to_string : t -> string
              val compare : t -> t -> int
            end
          module ComposeComparable :
            functor (P : Poly.Comparable->
              functor (M : Comparable->
                sig
                  type t = M.t P.t
                  val compare :
                    Reins.Types.Mono.ComposeComparable.t ->
                    Reins.Types.Mono.ComposeComparable.t -> int
                  val to_string :
                    Reins.Types.Mono.ComposeComparable.t -> string
                end
          module ComposeGen :
            functor (P : Poly.Arbitrary->
              functor (M : Arbitrary->
                sig
                  type t = M.t P.t
                  val gen :
                    ?size:int ->
                    Random.State.t -> Reins.Types.Mono.ComposeGen.t
                  val to_string : Reins.Types.Mono.ComposeGen.t -> string
                end
          module ComposeGenComparable :
            functor (P : Poly.ArbitraryComparable->
              functor (M : ArbitraryComparable->
                sig
                  type t = M.t P.t
                  val gen :
                    ?size:int ->
                    Random.State.t -> Reins.Types.Mono.ComposeGenComparable.t
                  val to_string :
                    Reins.Types.Mono.ComposeGenComparable.t -> string
                  val compare :
                    Reins.Types.Mono.ComposeGenComparable.t ->
                    Reins.Types.Mono.ComposeGenComparable.t -> int
                end
          module ComparablePair :
            functor (M1 : Comparable->
              functor (M2 : Comparable->
                sig
                  type t = M1.t * M2.t
                  val compare :
                    Reins.Types.Mono.ComparablePair.t ->
                    Reins.Types.Mono.ComparablePair.t -> int
                  val to_string : Reins.Types.Mono.ComparablePair.t -> string
                end
          module Comparable3Tuple :
            functor (M1 : Comparable->
              functor (M2 : Comparable->
                functor (M3 : Comparable->
                  sig
                    type t = M1.t * M2.t * M3.t
                    val compare :
                      Reins.Types.Mono.Comparable3Tuple.t ->
                      Reins.Types.Mono.Comparable3Tuple.t -> int
                    val to_string :
                      Reins.Types.Mono.Comparable3Tuple.t -> string
                  end
          module GenPair :
            functor (A : Arbitrary->
              functor (B : Arbitrary->
                sig
                  type t = A.t * B.t
                  val gen :
                    ?size:int -> Random.State.t -> Reins.Types.Mono.GenPair.t
                  val to_string : Reins.Types.Mono.GenPair.t -> string
                end
          module Gen3Tuple :
            functor (A : Arbitrary->
              functor (B : Arbitrary->
                functor (C : Arbitrary->
                  sig
                    type t = A.t * B.t * C.t
                    val gen :
                      ?size:int ->
                      Random.State.t -> Reins.Types.Mono.Gen3Tuple.t
                    val to_string : Reins.Types.Mono.Gen3Tuple.t -> string
                  end
        end
      module type Integral =
        sig
          type t
          val zero : Reins.Types.Integral.t
          val one : Reins.Types.Integral.t
          val minus_one : Reins.Types.Integral.t
          val abs : Reins.Types.Integral.t -> Reins.Types.Integral.t
          val neg : Reins.Types.Integral.t -> Reins.Types.Integral.t
          val succ : Reins.Types.Integral.t -> Reins.Types.Integral.t
          val pred : Reins.Types.Integral.t -> Reins.Types.Integral.t
          val add :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val sub :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val mul :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val div :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val rem :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val logand :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val lognot : Reins.Types.Integral.t -> Reins.Types.Integral.t
          val logor :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val logxor :
            Reins.Types.Integral.t ->
            Reins.Types.Integral.t -> Reins.Types.Integral.t
          val shift_left :
            Reins.Types.Integral.t -> int -> Reins.Types.Integral.t
          val shift_right :
            Reins.Types.Integral.t -> int -> Reins.Types.Integral.t
          val shift_right_logical :
            Reins.Types.Integral.t -> int -> Reins.Types.Integral.t
          val compare :
            Reins.Types.Integral.t -> Reins.Types.Integral.t -> int
          val of_int : int -> Reins.Types.Integral.t
          val to_int : Reins.Types.Integral.t -> int
          val of_float : float -> Reins.Types.Integral.t
          val to_float : Reins.Types.Integral.t -> float
          val to_string : Reins.Types.Integral.t -> string
          val of_string : string -> Reins.Types.Integral.t
        end
      module Int :
        sig
          type t = int
          val zero : int
          val one : int
          val minus_one : int
          val abs : int -> int
          val neg : int -> int
          val succ : int -> int
          val pred : int -> int
          val add : int -> int -> int
          val sub : int -> int -> int
          val mul : int -> int -> int
          val div : int -> int -> int
          val rem : int -> int -> int
          val logxor : int -> int -> int
          val logand : int -> int -> int
          val lognot : int -> int
          val logor : int -> int -> int
          val shift_left : int -> int -> int
          val shift_right : int -> int -> int
          val shift_right_logical : int -> int -> int
          val of_int : '-> 'a
          val to_int : '-> 'a
          val of_float : float -> int
          val to_float : int -> float
          val of_string : string -> int
          val compare : int -> int -> int
          val equal : int -> int -> bool
          val hash : '-> 'a
          val to_string : int -> string
          val gen : ?size:int -> Random.State.t -> int
        end
      module Float :
        sig
          type t = float
          val compare : float -> float -> int
          val equal : float -> float -> bool
          val hash : '-> int
          val gen : ?size:int -> Random.State.t -> float
          val to_string : float -> string
        end
      module Bool :
        sig
          type t = bool
          val compare : bool -> bool -> int
          val equal : bool -> bool -> bool
          val hash : '-> int
          val gen : ?size:'-> Random.State.t -> bool
          val to_string : bool -> string
        end
      module Char :
        sig
          type t = char
          val compare : char -> char -> int
          val equal : char -> char -> bool
          val hash : '-> int
          val gen : ?size:int -> Random.State.t -> char
          val to_string : char -> string
        end
      module Int32 :
        sig
          val zero : int32
          val one : int32
          val minus_one : int32
          external neg : int32 -> int32 = "%int32_neg"
          external add : int32 -> int32 -> int32 = "%int32_add"
          external sub : int32 -> int32 -> int32 = "%int32_sub"
          external mul : int32 -> int32 -> int32 = "%int32_mul"
          external div : int32 -> int32 -> int32 = "%int32_div"
          external rem : int32 -> int32 -> int32 = "%int32_mod"
          val succ : int32 -> int32
          val pred : int32 -> int32
          val abs : int32 -> int32
          val max_int : int32
          val min_int : int32
          external logand : int32 -> int32 -> int32 = "%int32_and"
          external logor : int32 -> int32 -> int32 = "%int32_or"
          external logxor : int32 -> int32 -> int32 = "%int32_xor"
          val lognot : int32 -> int32
          external shift_left : int32 -> int -> int32 = "%int32_lsl"
          external shift_right : int32 -> int -> int32 = "%int32_asr"
          external shift_right_logical : int32 -> int -> int32 = "%int32_lsr"
          external of_int : int -> int32 = "%int32_of_int"
          external to_int : int32 -> int = "%int32_to_int"
          external of_float : float -> int32 = "caml_int32_of_float"
          external to_float : int32 -> float = "caml_int32_to_float"
          external of_string : string -> int32 = "caml_int32_of_string"
          val to_string : int32 -> string
          external bits_of_float : float -> int32
            = "caml_int32_bits_of_float"
          external float_of_bits : int32 -> float
            = "caml_int32_float_of_bits"
          type t = int32
          val compare : Reins.Types.Int32.t -> Reins.Types.Int32.t -> int
          external format : string -> int32 -> string = "caml_int32_format"
          val equal : Reins.Types.Int32.t -> Reins.Types.Int32.t -> bool
          val hash : '-> int
          val gen : ?size:'-> Random.State.t -> Int32.t
        end
      module Int64 :
        sig
          val zero : int64
          val one : int64
          val minus_one : int64
          external neg : int64 -> int64 = "%int64_neg"
          external add : int64 -> int64 -> int64 = "%int64_add"
          external sub : int64 -> int64 -> int64 = "%int64_sub"
          external mul : int64 -> int64 -> int64 = "%int64_mul"
          external div : int64 -> int64 -> int64 = "%int64_div"
          external rem : int64 -> int64 -> int64 = "%int64_mod"
          val succ : int64 -> int64
          val pred : int64 -> int64
          val abs : int64 -> int64
          val max_int : int64
          val min_int : int64
          external logand : int64 -> int64 -> int64 = "%int64_and"
          external logor : int64 -> int64 -> int64 = "%int64_or"
          external logxor : int64 -> int64 -> int64 = "%int64_xor"
          val lognot : int64 -> int64
          external shift_left : int64 -> int -> int64 = "%int64_lsl"
          external shift_right : int64 -> int -> int64 = "%int64_asr"
          external shift_right_logical : int64 -> int -> int64 = "%int64_lsr"
          external of_int : int -> int64 = "%int64_of_int"
          external to_int : int64 -> int = "%int64_to_int"
          external of_float : float -> int64 = "caml_int64_of_float"
          external to_float : int64 -> float = "caml_int64_to_float"
          external of_int32 : int32 -> int64 = "%int64_of_int32"
          external to_int32 : int64 -> int32 = "%int64_to_int32"
          external of_nativeint : nativeint -> int64 = "%int64_of_nativeint"
          external to_nativeint : int64 -> nativeint = "%int64_to_nativeint"
          external of_string : string -> int64 = "caml_int64_of_string"
          val to_string : int64 -> string
          external bits_of_float : float -> int64
            = "caml_int64_bits_of_float"
          external float_of_bits : int64 -> float
            = "caml_int64_float_of_bits"
          type t = int64
          val compare : Reins.Types.Int64.t -> Reins.Types.Int64.t -> int
          external format : string -> int64 -> string = "caml_int64_format"
          val equal : Reins.Types.Int64.t -> Reins.Types.Int64.t -> bool
          val hash : '-> int
          val gen : ?size:'-> Random.State.t -> Int64.t
        end
      module Nativeint :
        sig
          val zero : nativeint
          val one : nativeint
          val minus_one : nativeint
          external neg : nativeint -> nativeint = "%nativeint_neg"
          external add : nativeint -> nativeint -> nativeint
            = "%nativeint_add"
          external sub : nativeint -> nativeint -> nativeint
            = "%nativeint_sub"
          external mul : nativeint -> nativeint -> nativeint
            = "%nativeint_mul"
          external div : nativeint -> nativeint -> nativeint
            = "%nativeint_div"
          external rem : nativeint -> nativeint -> nativeint
            = "%nativeint_mod"
          val succ : nativeint -> nativeint
          val pred : nativeint -> nativeint
          val abs : nativeint -> nativeint
          val size : int
          val max_int : nativeint
          val min_int : nativeint
          external logand : nativeint -> nativeint -> nativeint
            = "%nativeint_and"
          external logor : nativeint -> nativeint -> nativeint
            = "%nativeint_or"
          external logxor : nativeint -> nativeint -> nativeint
            = "%nativeint_xor"
          val lognot : nativeint -> nativeint
          external shift_left : nativeint -> int -> nativeint
            = "%nativeint_lsl"
          external shift_right : nativeint -> int -> nativeint
            = "%nativeint_asr"
          external shift_right_logical : nativeint -> int -> nativeint
            = "%nativeint_lsr"
          external of_int : int -> nativeint = "%nativeint_of_int"
          external to_int : nativeint -> int = "%nativeint_to_int"
          external of_float : float -> nativeint = "caml_nativeint_of_float"
          external to_float : nativeint -> float = "caml_nativeint_to_float"
          external of_int32 : int32 -> nativeint = "%nativeint_of_int32"
          external to_int32 : nativeint -> int32 = "%nativeint_to_int32"
          external of_string : string -> nativeint
            = "caml_nativeint_of_string"
          val to_string : nativeint -> string
          type t = nativeint
          val compare :
            Reins.Types.Nativeint.t -> Reins.Types.Nativeint.t -> int
          external format : string -> nativeint -> string
            = "caml_nativeint_format"
          val equal :
            Reins.Types.Nativeint.t -> Reins.Types.Nativeint.t -> bool
          val hash : '-> int
          val gen : ?size:'-> Random.State.t -> Nativeint.t
        end
      module Big_int :
        sig
          type big_int = Big_int.big_int
          val zero_big_int : Reins.Types.Big_int.big_int
          val unit_big_int : Reins.Types.Big_int.big_int
          val minus_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val abs_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val add_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val succ_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val add_int_big_int :
            int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val sub_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val pred_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val mult_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val mult_int_big_int :
            int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val square_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val sqrt_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val quomod_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int * Reins.Types.Big_int.big_int
          val div_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val mod_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val gcd_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val power_int_positive_int :
            int -> int -> Reins.Types.Big_int.big_int
          val power_big_int_positive_int :
            Reins.Types.Big_int.big_int -> int -> Reins.Types.Big_int.big_int
          val power_int_positive_big_int :
            int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val power_big_int_positive_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val sign_big_int : Reins.Types.Big_int.big_int -> int
          val compare_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int -> int
          val eq_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> bool
          val le_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> bool
          val ge_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> bool
          val lt_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> bool
          val gt_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> bool
          val max_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val min_big_int :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val num_digits_big_int : Reins.Types.Big_int.big_int -> int
          val string_of_big_int : Reins.Types.Big_int.big_int -> string
          val big_int_of_string : string -> Reins.Types.Big_int.big_int
          val big_int_of_int : int -> Reins.Types.Big_int.big_int
          val is_int_big_int : Reins.Types.Big_int.big_int -> bool
          val int_of_big_int : Reins.Types.Big_int.big_int -> int
          val float_of_big_int : Reins.Types.Big_int.big_int -> float
          val nat_of_big_int : Reins.Types.Big_int.big_int -> Nat.nat
          val big_int_of_nat : Nat.nat -> Reins.Types.Big_int.big_int
          val base_power_big_int :
            int ->
            int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val sys_big_int_of_string :
            string -> int -> int -> Reins.Types.Big_int.big_int
          val round_futur_last_digit : string -> int -> int -> bool
          val approx_big_int : int -> Reins.Types.Big_int.big_int -> string
          type t = Reins.Types.Big_int.big_int
          val equal :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> bool
          val compare :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> bool
          val hash : '-> int
          val gen : ?size:'-> Random.State.t -> Big_int.big_int
          val zero : Reins.Types.Big_int.big_int
          val one : Reins.Types.Big_int.big_int
          val minus_one : Reins.Types.Big_int.big_int
          val abs :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val neg :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val succ :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val pred :
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val add :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val sub :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val mul :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val div :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val rem :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val of_int : '-> int -> Reins.Types.Big_int.big_int
          val to_int : '-> Reins.Types.Big_int.big_int -> int
          val of_float : float -> Reins.Types.Big_int.big_int
          val to_float : Reins.Types.Big_int.big_int -> float
          val to_string : Reins.Types.Big_int.big_int -> string
          val of_string : string -> Reins.Types.Big_int.big_int
        end
      module Ratio :
        sig
          type ratio = Ratio.ratio
          val null_denominator : Reins.Types.Ratio.ratio -> bool
          val numerator_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
          val denominator_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
          val sign_ratio : Reins.Types.Ratio.ratio -> int
          val normalize_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val cautious_normalize_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val cautious_normalize_ratio_when_printing :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val create_ratio :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
          val create_normalized_ratio :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
          val is_normalized_ratio : Reins.Types.Ratio.ratio -> bool
          val report_sign_ratio :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
          val abs_ratio : Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val is_integer_ratio : Reins.Types.Ratio.ratio -> bool
          val add_ratio :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val minus_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val add_int_ratio :
            int -> Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val add_big_int_ratio :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val sub_ratio :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val mult_ratio :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val mult_int_ratio :
            int -> Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val mult_big_int_ratio :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val square_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val inverse_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val div_ratio :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val integer_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
          val floor_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
          val round_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
          val ceiling_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
          val eq_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
          val compare_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> int
          val lt_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
          val le_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
          val gt_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
          val ge_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
          val max_ratio :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val min_ratio :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val eq_big_int_ratio :
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
          val compare_big_int_ratio :
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> int
          val lt_big_int_ratio :
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
          val le_big_int_ratio :
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
          val gt_big_int_ratio :
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
          val ge_big_int_ratio :
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
          val int_of_ratio : Reins.Types.Ratio.ratio -> int
          val ratio_of_int : int -> Reins.Types.Ratio.ratio
          val ratio_of_nat : Nat.nat -> Reins.Types.Ratio.ratio
          val nat_of_ratio : Reins.Types.Ratio.ratio -> Nat.nat
          val ratio_of_big_int :
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
          val big_int_of_ratio :
            Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
          val div_int_ratio :
            int -> Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val div_ratio_int :
            Reins.Types.Ratio.ratio -> int -> Reins.Types.Ratio.ratio
          val div_big_int_ratio :
            Reins.Types.Big_int.big_int ->
            Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
          val div_ratio_big_int :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
          val approx_ratio_fix : int -> Reins.Types.Ratio.ratio -> string
          val approx_ratio_exp : int -> Reins.Types.Ratio.ratio -> string
          val float_of_rational_string : Reins.Types.Ratio.ratio -> string
          val string_of_ratio : Reins.Types.Ratio.ratio -> string
          val ratio_of_string : string -> Reins.Types.Ratio.ratio
          val float_of_ratio : Reins.Types.Ratio.ratio -> float
          val power_ratio_positive_int :
            Reins.Types.Ratio.ratio -> int -> Reins.Types.Ratio.ratio
          val power_ratio_positive_big_int :
            Reins.Types.Ratio.ratio ->
            Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
          val equal : '-> '-> bool
          val hash : '-> int
          val gen : ?size:'-> Random.State.t -> Ratio.ratio
        end
      module Complex :
        sig
          type t = Complex.t = { re : float; im : float; }
          val zero : Reins.Types.Complex.t
          val one : Reins.Types.Complex.t
          val i : Reins.Types.Complex.t
          val neg : Reins.Types.Complex.t -> Reins.Types.Complex.t
          val conj : Reins.Types.Complex.t -> Reins.Types.Complex.t
          val add :
            Reins.Types.Complex.t ->
            Reins.Types.Complex.t -> Reins.Types.Complex.t
          val sub :
            Reins.Types.Complex.t ->
            Reins.Types.Complex.t -> Reins.Types.Complex.t
          val mul :
            Reins.Types.Complex.t ->
            Reins.Types.Complex.t -> Reins.Types.Complex.t
          val inv : Reins.Types.Complex.t -> Reins.Types.Complex.t
          val div :
            Reins.Types.Complex.t ->
            Reins.Types.Complex.t -> Reins.Types.Complex.t
          val sqrt : Reins.Types.Complex.t -> Reins.Types.Complex.t
          val norm2 : Reins.Types.Complex.t -> float
          val norm : Reins.Types.Complex.t -> float
          val arg : Reins.Types.Complex.t -> float
          val polar : float -> float -> Reins.Types.Complex.t
          val exp : Reins.Types.Complex.t -> Reins.Types.Complex.t
          val log : Reins.Types.Complex.t -> Reins.Types.Complex.t
          val pow :
            Reins.Types.Complex.t ->
            Reins.Types.Complex.t -> Reins.Types.Complex.t
          val equal : '-> '-> bool
          val hash : '-> int
          val gen : ?size:'-> Random.State.t -> Complex.t
        end
      module String :
        sig
          external length : string -> int = "%string_length"
          external get : string -> int -> char = "%string_safe_get"
          external set : string -> int -> char -> unit = "%string_safe_set"
          external create : int -> string = "caml_create_string"
          val make : int -> char -> string
          val copy : string -> string
          val sub : string -> int -> int -> string
          val fill : string -> int -> int -> char -> unit
          val blit : string -> int -> string -> int -> int -> unit
          val concat : string -> string list -> string
          val iter : (char -> unit) -> string -> unit
          val escaped : string -> string
          val index : string -> char -> int
          val rindex : string -> char -> int
          val index_from : string -> int -> char -> int
          val rindex_from : string -> int -> char -> int
          val contains : string -> char -> bool
          val contains_from : string -> int -> char -> bool
          val rcontains_from : string -> int -> char -> bool
          val uppercase : string -> string
          val lowercase : string -> string
          val capitalize : string -> string
          val uncapitalize : string -> string
          type t = string
          val compare : Reins.Types.String.t -> Reins.Types.String.t -> int
          external unsafe_get : string -> int -> char = "%string_unsafe_get"
          external unsafe_set : string -> int -> char -> unit
            = "%string_unsafe_set"
          external unsafe_blit :
            string -> int -> string -> int -> int -> unit
            = "caml_blit_string" "noalloc"
          external unsafe_fill : string -> int -> int -> char -> unit
            = "caml_fill_string" "noalloc"
          val equal : Reins.Types.String.t -> Reins.Types.String.t -> bool
          val hash : '-> int
          val gen : ?size:int -> Random.State.t -> string
          val to_string : '-> 'a
        end
      module Option :
        sig
          type 'a t = 'a option
          val compare : ('-> '-> int) -> 'a option -> 'b option -> int
          val equal : 'a option -> 'a option -> bool
          val gen :
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a option
          val to_string : ('-> string) -> 'a option -> string
        end
    end
  module Quickcheck :
    sig
      exception Trivial
      module type Law =
        sig
          module Arg : Types.Mono.Arbitrary
          val desc : string
          val law : Arg.t -> bool
        end
      module type Config =
        sig
          val num_iterations : int
          val size_arg : int option
          val max_trivial_percentage : float
        end
      module Check :
        functor (Conf : Config->
          functor (L : Law->
            sig val desc : string val test : Random.State.t -> unit end
    end
  module Heaps :
    sig
      module type Heap_ =
        sig
          type 'a elt_
          type 'a heap
          val empty : 'Reins.Heaps.Heap_.heap
          val is_empty : 'Reins.Heaps.Heap_.heap -> bool
          val singleton :
            'Reins.Heaps.Heap_.elt_ -> 'Reins.Heaps.Heap_.heap
          val insert :
            'Reins.Heaps.Heap_.elt_ ->
            'Reins.Heaps.Heap_.heap -> 'Reins.Heaps.Heap_.heap
          val merge :
            'Reins.Heaps.Heap_.heap ->
            'Reins.Heaps.Heap_.heap -> 'Reins.Heaps.Heap_.heap
          val find_min :
            'Reins.Heaps.Heap_.heap -> 'Reins.Heaps.Heap_.elt_
          val delete_min :
            'Reins.Heaps.Heap_.heap -> 'Reins.Heaps.Heap_.heap
        end
      module type MonoHeapSig =
        sig
          type t
          type elt
          type 'a elt_ = elt
          type 'a heap = t
          val empty : 'a heap
          val is_empty : 'a heap -> bool
          val singleton : 'a elt_ -> 'a heap
          val insert : 'a elt_ -> 'a heap -> 'a heap
          val merge : 'a heap -> 'a heap -> 'a heap
          val find_min : 'a heap -> 'a elt_
          val delete_min : 'a heap -> 'a heap
          val to_string : 'a heap -> string
        end
      module type MonoHeapSigFn =
        functor (C : Types.Mono.Comparable->
          sig
            type t
            type elt = C.t
            type 'a elt_ = elt
            type 'a heap = t
            val empty : 'a heap
            val is_empty : 'a heap -> bool
            val singleton : 'a elt_ -> 'a heap
            val insert : 'a elt_ -> 'a heap -> 'a heap
            val merge : 'a heap -> 'a heap -> 'a heap
            val find_min : 'a heap -> 'a elt_
            val delete_min : 'a heap -> 'a heap
            val to_string : 'a heap -> string
          end
      module type GenHeapSig =
        sig
          type t
          type elt
          type 'a elt_ = elt
          type 'a heap = t
          val empty : 'a heap
          val is_empty : 'a heap -> bool
          val singleton : 'a elt_ -> 'a heap
          val insert : 'a elt_ -> 'a heap -> 'a heap
          val merge : 'a heap -> 'a heap -> 'a heap
          val find_min : 'a heap -> 'a elt_
          val delete_min : 'a heap -> 'a heap
          val to_string : 'a heap -> string
          val gen : ?size:int -> Random.State.t -> t
        end
      module type GenHeapSigFn =
        functor (C : Types.Mono.ArbitraryComparable->
          sig
            type t
            type elt = C.t
            type 'a elt_ = elt
            type 'a heap = t
            val empty : 'a heap
            val is_empty : 'a heap -> bool
            val singleton : 'a elt_ -> 'a heap
            val insert : 'a elt_ -> 'a heap -> 'a heap
            val merge : 'a heap -> 'a heap -> 'a heap
            val find_min : 'a heap -> 'a elt_
            val delete_min : 'a heap -> 'a heap
            val to_string : 'a heap -> string
            val gen : ?size:int -> Random.State.t -> t
          end
      module type PolyHeapSig =
        sig
          type 'a t
          type 'a elt_ = 'a
          type 'a heap = 'a t
          val empty : 'a heap
          val is_empty : 'a heap -> bool
          val singleton : 'a elt_ -> 'a heap
          val insert : 'a elt_ -> 'a heap -> 'a heap
          val merge : 'a heap -> 'a heap -> 'a heap
          val find_min : 'a heap -> 'a elt_
          val delete_min : 'a heap -> 'a heap
          val to_string : ('-> string) -> 'a heap -> string
        end
    end
  module BinomialHeap :
    sig
      module MonoHeap : Heaps.MonoHeapSigFn
      module GenHeap : Heaps.GenHeapSigFn
      module PolyHeap : Heaps.PolyHeapSig
    end
  module SkewBinomialHeap :
    sig
      module MonoHeap : Heaps.MonoHeapSigFn
      module GenHeap : Heaps.GenHeapSigFn
      module PolyHeap : Heaps.PolyHeapSig
    end
  module Iterator :
    sig
      module type S =
        sig
          type 'a t
          type 'a elt
          type 'a cursor
          type 'a collection
          type direction
          type 'a traversal =
              Traverse_All
            | Traverse_If of ('-> bool)
            | Traverse_While of ('-> bool)
          val create :
            Reins.Iterator.S.direction ->
            'Reins.Iterator.S.elt Reins.Iterator.S.traversal ->
            'Reins.Iterator.S.collection -> 'Reins.Iterator.S.t
          val from_cursor :
            Reins.Iterator.S.direction ->
            'Reins.Iterator.S.elt Reins.Iterator.S.traversal ->
            'Reins.Iterator.S.cursor -> 'Reins.Iterator.S.t
          val value : 'Reins.Iterator.S.t -> 'Reins.Iterator.S.elt option
          val get_value : 'Reins.Iterator.S.t -> 'Reins.Iterator.S.elt
          val at_end : 'Reins.Iterator.S.t -> bool
          val at_beg : 'Reins.Iterator.S.t -> bool
          val has_next : 'Reins.Iterator.S.t -> bool
          val next : 'Reins.Iterator.S.t -> 'Reins.Iterator.S.t
          val has_prev : 'Reins.Iterator.S.t -> bool
          val prev : 'Reins.Iterator.S.t -> 'Reins.Iterator.S.t
          val goto_beg : 'Reins.Iterator.S.t -> 'Reins.Iterator.S.t
          val goto_end : 'Reins.Iterator.S.t -> 'Reins.Iterator.S.t
          val flip : 'Reins.Iterator.S.t -> 'Reins.Iterator.S.t
          val iter :
            ('Reins.Iterator.S.elt -> unit) ->
            'Reins.Iterator.S.t -> unit
          val fold :
            ('-> 'Reins.Iterator.S.elt -> 'a) ->
            '-> 'Reins.Iterator.S.t -> 'a
        end
    end
  module Lists :
    sig
      module type ListSig =
        sig
          type 'a t
          val empty : 'Reins.Lists.ListSig.t
          val is_empty : 'Reins.Lists.ListSig.t -> bool
          val length : 'Reins.Lists.ListSig.t -> int
          val rev : 'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t
          val cons :
            '-> 'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t
          val snoc :
            '-> 'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t
          val hd : 'Reins.Lists.ListSig.t -> 'a
          val tl : 'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t
          val pop : 'Reins.Lists.ListSig.t -> 'a * 'Reins.Lists.ListSig.t
          val last : 'Reins.Lists.ListSig.t -> 'a
          val append :
            'Reins.Lists.ListSig.t ->
            'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t
          val flatten :
            'Reins.Lists.ListSig.t Reins.Lists.ListSig.t ->
            'Reins.Lists.ListSig.t
          val from_list : 'a list -> 'Reins.Lists.ListSig.t
          val to_list : 'Reins.Lists.ListSig.t -> 'a list
          val iter : ('-> unit) -> 'Reins.Lists.ListSig.t -> unit
          val fold : ('-> '-> 'a) -> '-> 'Reins.Lists.ListSig.t -> 'a
          val rev_map :
            ('-> 'b) ->
            'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t
          val map :
            ('-> 'b) ->
            'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t
          val to_string :
            ('-> string) -> 'Reins.Lists.ListSig.t -> string
          val compare :
            ('-> '-> int) ->
            'Reins.Lists.ListSig.t -> 'Reins.Lists.ListSig.t -> int
          val gen :
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'Reins.Lists.ListSig.t
        end
    end
  module ListCursor :
    sig
      module type S =
        sig
          type 'a list_
          type 'a cursor
          val to_cursor :
            'Reins.ListCursor.S.list_ -> 'Reins.ListCursor.S.cursor
          val from_cursor :
            'Reins.ListCursor.S.cursor -> 'Reins.ListCursor.S.list_
          val at_front : 'Reins.ListCursor.S.cursor -> bool
          val at_back : 'Reins.ListCursor.S.cursor -> bool
          val move_next :
            'Reins.ListCursor.S.cursor -> 'Reins.ListCursor.S.cursor
          val move_prev :
            'Reins.ListCursor.S.cursor -> 'Reins.ListCursor.S.cursor
          val goto_front :
            'Reins.ListCursor.S.cursor -> 'Reins.ListCursor.S.cursor
          val goto_back :
            'Reins.ListCursor.S.cursor -> 'Reins.ListCursor.S.cursor
          val value : 'Reins.ListCursor.S.cursor -> 'a option
          val list :
            'Reins.ListCursor.S.cursor -> 'Reins.ListCursor.S.list_
          val replace_list :
            'Reins.ListCursor.S.list_ ->
            'Reins.ListCursor.S.cursor -> 'Reins.ListCursor.S.cursor
        end
      module Make :
        functor (L : Lists.ListSig->
          sig
            type 'a list_ = 'L.t
            type 'a cursor
            val to_cursor : 'a list_ -> 'a cursor
            val from_cursor : 'a cursor -> 'a list_
            val at_front : 'a cursor -> bool
            val at_back : 'a cursor -> bool
            val move_next : 'a cursor -> 'a cursor
            val move_prev : 'a cursor -> 'a cursor
            val goto_front : 'a cursor -> 'a cursor
            val goto_back : 'a cursor -> 'a cursor
            val value : 'a cursor -> 'a option
            val list : 'a cursor -> 'a list_
            val replace_list : 'a list_ -> 'a cursor -> 'a cursor
          end
    end
  module ListIterator :
    sig
      module type S =
        sig
          type direction_ = Left_Right | Right_Left
          type 'a t
          type 'a elt
          type 'a cursor
          type 'a collection
          type direction = direction_
          type 'a traversal =
              Traverse_All
            | Traverse_If of ('-> bool)
            | Traverse_While of ('-> bool)
          val create : direction -> 'a elt traversal -> 'a collection -> 'a t
          val from_cursor :
            direction -> 'a elt traversal -> 'a cursor -> 'a t
          val value : 'a t -> 'a elt option
          val get_value : 'a t -> 'a elt
          val at_end : 'a t -> bool
          val at_beg : 'a t -> bool
          val has_next : 'a t -> bool
          val next : 'a t -> 'a t
          val has_prev : 'a t -> bool
          val prev : 'a t -> 'a t
          val goto_beg : 'a t -> 'a t
          val goto_end : 'a t -> 'a t
          val flip : 'a t -> 'a t
          val iter : ('a elt -> unit) -> 'a t -> unit
          val fold : ('-> 'b elt -> 'a) -> '-> 'b t -> 'a
        end
      module Make :
        functor (I : ListCursor.S->
          sig
            type direction_ = Left_Right | Right_Left
            type 'a t
            type 'a elt = 'a
            type 'a cursor = 'I.cursor
            type 'a collection = 'I.list_
            type direction = direction_
            type 'a traversal =
                Traverse_All
              | Traverse_If of ('-> bool)
              | Traverse_While of ('-> bool)
            val create :
              direction -> 'a elt traversal -> 'a collection -> 'a t
            val from_cursor :
              direction -> 'a elt traversal -> 'a cursor -> 'a t
            val value : 'a t -> 'a elt option
            val get_value : 'a t -> 'a elt
            val at_end : 'a t -> bool
            val at_beg : 'a t -> bool
            val has_next : 'a t -> bool
            val next : 'a t -> 'a t
            val has_prev : 'a t -> bool
            val prev : 'a t -> 'a t
            val goto_beg : 'a t -> 'a t
            val goto_end : 'a t -> 'a t
            val flip : 'a t -> 'a t
            val iter : ('a elt -> unit) -> 'a t -> unit
            val fold : ('-> 'b elt -> 'a) -> '-> 'b t -> 'a
          end
      module From_List :
        functor (L : Lists.ListSig->
          sig
            type direction_ = Left_Right | Right_Left
            type 'a t
            type 'a elt = 'a
            type 'a cursor = 'ListCursor.Make(L).cursor
            type 'a collection = 'L.t
            type direction = direction_
            type 'a traversal =
                Traverse_All
              | Traverse_If of ('-> bool)
              | Traverse_While of ('-> bool)
            val create :
              direction -> 'a elt traversal -> 'a collection -> 'a t
            val from_cursor :
              direction -> 'a elt traversal -> 'a cursor -> 'a t
            val value : 'a t -> 'a elt option
            val get_value : 'a t -> 'a elt
            val at_end : 'a t -> bool
            val at_beg : 'a t -> bool
            val has_next : 'a t -> bool
            val next : 'a t -> 'a t
            val has_prev : 'a t -> bool
            val prev : 'a t -> 'a t
            val goto_beg : 'a t -> 'a t
            val goto_end : 'a t -> 'a t
            val flip : 'a t -> 'a t
            val iter : ('a elt -> unit) -> 'a t -> unit
            val fold : ('-> 'b elt -> 'a) -> '-> 'b t -> 'a
          end
    end
  module Sets :
    sig
      module type Set_ =
        sig
          type 'a elt_
          type 'a set
          type ('a, 'b) result_
          val empty : 'Reins.Sets.Set_.set
          val is_empty : 'Reins.Sets.Set_.set -> bool
          val mem :
            'Reins.Sets.Set_.elt_ ->
            'Reins.Sets.Set_.set -> (bool, 'a) Reins.Sets.Set_.result_
          val add :
            'Reins.Sets.Set_.elt_ ->
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.set
          val singleton : 'Reins.Sets.Set_.elt_ -> 'Reins.Sets.Set_.set
          val remove :
            'Reins.Sets.Set_.elt_ ->
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.set
          val min_elt :
            'Reins.Sets.Set_.set ->
            ('Reins.Sets.Set_.elt_, 'a) Reins.Sets.Set_.result_
          val max_elt :
            'Reins.Sets.Set_.set ->
            ('Reins.Sets.Set_.elt_, 'a) Reins.Sets.Set_.result_
          val choose :
            'Reins.Sets.Set_.set ->
            ('Reins.Sets.Set_.elt_, 'a) Reins.Sets.Set_.result_
          val cardinal : 'Reins.Sets.Set_.set -> int
          val compare :
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.set -> int
          val equal :
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.set -> bool
          val iter :
            ('Reins.Sets.Set_.elt_ -> unit) ->
            'Reins.Sets.Set_.set -> unit
          val fold :
            ('-> 'Reins.Sets.Set_.elt_ -> 'a) ->
            '-> 'Reins.Sets.Set_.set -> 'a
          val union :
            'Reins.Sets.Set_.set ->
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.set
          val inter :
            'Reins.Sets.Set_.set ->
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.set
          val diff :
            'Reins.Sets.Set_.set ->
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.set
          val gen1 :
            (?size:int -> Random.State.t -> 'Reins.Sets.Set_.elt_) ->
            ?size:int -> Random.State.t -> 'Reins.Sets.Set_.set
          val well_formed : 'Reins.Sets.Set_.set -> bool
          val of_result : ('a, 'b) Reins.Sets.Set_.result_ -> 'a
          type 'a cursor_
          val to_cursor :
            'Reins.Sets.Set_.set -> 'Reins.Sets.Set_.cursor_
          val from_cursor :
            'Reins.Sets.Set_.cursor_ -> 'Reins.Sets.Set_.set
          val at_top : 'Reins.Sets.Set_.cursor_ -> bool
          val at_left : 'Reins.Sets.Set_.cursor_ -> bool
          val at_right : 'Reins.Sets.Set_.cursor_ -> bool
          val move_up :
            'Reins.Sets.Set_.cursor_ -> 'Reins.Sets.Set_.cursor_
          val move_down_left :
            'Reins.Sets.Set_.cursor_ -> 'Reins.Sets.Set_.cursor_
          val move_down_right :
            'Reins.Sets.Set_.cursor_ -> 'Reins.Sets.Set_.cursor_
          val went_left : 'Reins.Sets.Set_.cursor_ -> bool
          val went_right : 'Reins.Sets.Set_.cursor_ -> bool
          val has_value : 'Reins.Sets.Set_.cursor_ -> bool
          val get_value :
            'Reins.Sets.Set_.cursor_ -> 'Reins.Sets.Set_.elt_
        end
      module type MonoSetSig =
        sig
          type t
          type elt
          type cursor
          type 'a result
          type 'a elt_ = elt
          type 'a set = t
          type ('a, 'b) result_ = 'a result
          val empty : 'a set
          val is_empty : 'a set -> bool
          val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
          val add : 'a elt_ -> 'a set -> 'a set
          val singleton : 'a elt_ -> 'a set
          val remove : 'a elt_ -> 'a set -> 'a set
          val min_elt : 'a set -> ('a elt_, 'a) result_
          val max_elt : 'a set -> ('a elt_, 'a) result_
          val choose : 'a set -> ('a elt_, 'a) result_
          val cardinal : 'a set -> int
          val compare : 'a set -> 'a set -> int
          val equal : 'a set -> 'a set -> bool
          val iter : ('a elt_ -> unit) -> 'a set -> unit
          val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
          val union : 'a set -> 'a set -> 'a set
          val inter : 'a set -> 'a set -> 'a set
          val diff : 'a set -> 'a set -> 'a set
          val gen1 :
            (?size:int -> Random.State.t -> 'a elt_) ->
            ?size:int -> Random.State.t -> 'a set
          val well_formed : 'a set -> bool
          val of_result : ('a, 'b) result_ -> 'a
          type 'a cursor_ = cursor
          val to_cursor : 'a set -> 'a cursor_
          val from_cursor : 'a cursor_ -> 'a set
          val at_top : 'a cursor_ -> bool
          val at_left : 'a cursor_ -> bool
          val at_right : 'a cursor_ -> bool
          val move_up : 'a cursor_ -> 'a cursor_
          val move_down_left : 'a cursor_ -> 'a cursor_
          val move_down_right : 'a cursor_ -> 'a cursor_
          val went_left : 'a cursor_ -> bool
          val went_right : 'a cursor_ -> bool
          val has_value : 'a cursor_ -> bool
          val get_value : 'a cursor_ -> 'a elt_
          val to_string : 'a set -> string
        end
      module type MonoSetSigFn =
        functor (C : Types.Mono.Comparable->
          sig
            type t
            type elt = C.t
            type cursor
            type 'a result
            type 'a elt_ = elt
            type 'a set = t
            type ('a, 'b) result_ = 'a result
            val empty : 'a set
            val is_empty : 'a set -> bool
            val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
            val add : 'a elt_ -> 'a set -> 'a set
            val singleton : 'a elt_ -> 'a set
            val remove : 'a elt_ -> 'a set -> 'a set
            val min_elt : 'a set -> ('a elt_, 'a) result_
            val max_elt : 'a set -> ('a elt_, 'a) result_
            val choose : 'a set -> ('a elt_, 'a) result_
            val cardinal : 'a set -> int
            val compare : 'a set -> 'a set -> int
            val equal : 'a set -> 'a set -> bool
            val iter : ('a elt_ -> unit) -> 'a set -> unit
            val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
            val union : 'a set -> 'a set -> 'a set
            val inter : 'a set -> 'a set -> 'a set
            val diff : 'a set -> 'a set -> 'a set
            val gen1 :
              (?size:int -> Random.State.t -> 'a elt_) ->
              ?size:int -> Random.State.t -> 'a set
            val well_formed : 'a set -> bool
            val of_result : ('a, 'b) result_ -> 'a
            type 'a cursor_ = cursor
            val to_cursor : 'a set -> 'a cursor_
            val from_cursor : 'a cursor_ -> 'a set
            val at_top : 'a cursor_ -> bool
            val at_left : 'a cursor_ -> bool
            val at_right : 'a cursor_ -> bool
            val move_up : 'a cursor_ -> 'a cursor_
            val move_down_left : 'a cursor_ -> 'a cursor_
            val move_down_right : 'a cursor_ -> 'a cursor_
            val went_left : 'a cursor_ -> bool
            val went_right : 'a cursor_ -> bool
            val has_value : 'a cursor_ -> bool
            val get_value : 'a cursor_ -> 'a elt_
            val to_string : 'a set -> string
          end
      module type MonoSetSigFnStd =
        functor (C : Types.Mono.Comparable->
          sig
            type t
            type elt = C.t
            type cursor
            type 'a result = 'a
            type 'a elt_ = elt
            type 'a set = t
            type ('a, 'b) result_ = 'a result
            val empty : 'a set
            val is_empty : 'a set -> bool
            val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
            val add : 'a elt_ -> 'a set -> 'a set
            val singleton : 'a elt_ -> 'a set
            val remove : 'a elt_ -> 'a set -> 'a set
            val min_elt : 'a set -> ('a elt_, 'a) result_
            val max_elt : 'a set -> ('a elt_, 'a) result_
            val choose : 'a set -> ('a elt_, 'a) result_
            val cardinal : 'a set -> int
            val compare : 'a set -> 'a set -> int
            val equal : 'a set -> 'a set -> bool
            val iter : ('a elt_ -> unit) -> 'a set -> unit
            val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
            val union : 'a set -> 'a set -> 'a set
            val inter : 'a set -> 'a set -> 'a set
            val diff : 'a set -> 'a set -> 'a set
            val gen1 :
              (?size:int -> Random.State.t -> 'a elt_) ->
              ?size:int -> Random.State.t -> 'a set
            val well_formed : 'a set -> bool
            val of_result : ('a, 'b) result_ -> 'a
            type 'a cursor_ = cursor
            val to_cursor : 'a set -> 'a cursor_
            val from_cursor : 'a cursor_ -> 'a set
            val at_top : 'a cursor_ -> bool
            val at_left : 'a cursor_ -> bool
            val at_right : 'a cursor_ -> bool
            val move_up : 'a cursor_ -> 'a cursor_
            val move_down_left : 'a cursor_ -> 'a cursor_
            val move_down_right : 'a cursor_ -> 'a cursor_
            val went_left : 'a cursor_ -> bool
            val went_right : 'a cursor_ -> bool
            val has_value : 'a cursor_ -> bool
            val get_value : 'a cursor_ -> 'a elt_
            val to_string : 'a set -> string
          end
      module type GenSetSig =
        sig
          type t
          type elt
          type cursor
          type 'a result
          type 'a elt_ = elt
          type 'a set = t
          type ('a, 'b) result_ = 'a result
          val empty : 'a set
          val is_empty : 'a set -> bool
          val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
          val add : 'a elt_ -> 'a set -> 'a set
          val singleton : 'a elt_ -> 'a set
          val remove : 'a elt_ -> 'a set -> 'a set
          val min_elt : 'a set -> ('a elt_, 'a) result_
          val max_elt : 'a set -> ('a elt_, 'a) result_
          val choose : 'a set -> ('a elt_, 'a) result_
          val cardinal : 'a set -> int
          val compare : 'a set -> 'a set -> int
          val equal : 'a set -> 'a set -> bool
          val iter : ('a elt_ -> unit) -> 'a set -> unit
          val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
          val union : 'a set -> 'a set -> 'a set
          val inter : 'a set -> 'a set -> 'a set
          val diff : 'a set -> 'a set -> 'a set
          val gen1 :
            (?size:int -> Random.State.t -> 'a elt_) ->
            ?size:int -> Random.State.t -> 'a set
          val well_formed : 'a set -> bool
          val of_result : ('a, 'b) result_ -> 'a
          type 'a cursor_ = cursor
          val to_cursor : 'a set -> 'a cursor_
          val from_cursor : 'a cursor_ -> 'a set
          val at_top : 'a cursor_ -> bool
          val at_left : 'a cursor_ -> bool
          val at_right : 'a cursor_ -> bool
          val move_up : 'a cursor_ -> 'a cursor_
          val move_down_left : 'a cursor_ -> 'a cursor_
          val move_down_right : 'a cursor_ -> 'a cursor_
          val went_left : 'a cursor_ -> bool
          val went_right : 'a cursor_ -> bool
          val has_value : 'a cursor_ -> bool
          val get_value : 'a cursor_ -> 'a elt_
          val to_string : 'a set -> string
          val gen : ?size:int -> Random.State.t -> t
        end
      module type GenSetSigFn =
        functor (C : Types.Mono.ArbitraryComparable->
          sig
            type t
            type elt = C.t
            type cursor
            type 'a result
            type 'a elt_ = elt
            type 'a set = t
            type ('a, 'b) result_ = 'a result
            val empty : 'a set
            val is_empty : 'a set -> bool
            val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
            val add : 'a elt_ -> 'a set -> 'a set
            val singleton : 'a elt_ -> 'a set
            val remove : 'a elt_ -> 'a set -> 'a set
            val min_elt : 'a set -> ('a elt_, 'a) result_
            val max_elt : 'a set -> ('a elt_, 'a) result_
            val choose : 'a set -> ('a elt_, 'a) result_
            val cardinal : 'a set -> int
            val compare : 'a set -> 'a set -> int
            val equal : 'a set -> 'a set -> bool
            val iter : ('a elt_ -> unit) -> 'a set -> unit
            val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
            val union : 'a set -> 'a set -> 'a set
            val inter : 'a set -> 'a set -> 'a set
            val diff : 'a set -> 'a set -> 'a set
            val gen1 :
              (?size:int -> Random.State.t -> 'a elt_) ->
              ?size:int -> Random.State.t -> 'a set
            val well_formed : 'a set -> bool
            val of_result : ('a, 'b) result_ -> 'a
            type 'a cursor_ = cursor
            val to_cursor : 'a set -> 'a cursor_
            val from_cursor : 'a cursor_ -> 'a set
            val at_top : 'a cursor_ -> bool
            val at_left : 'a cursor_ -> bool
            val at_right : 'a cursor_ -> bool
            val move_up : 'a cursor_ -> 'a cursor_
            val move_down_left : 'a cursor_ -> 'a cursor_
            val move_down_right : 'a cursor_ -> 'a cursor_
            val went_left : 'a cursor_ -> bool
            val went_right : 'a cursor_ -> bool
            val has_value : 'a cursor_ -> bool
            val get_value : 'a cursor_ -> 'a elt_
            val to_string : 'a set -> string
            val gen : ?size:int -> Random.State.t -> t
          end
      module type GenSetSigFnStd =
        functor (C : Types.Mono.ArbitraryComparable->
          sig
            type t
            type elt = C.t
            type cursor
            type 'a result = 'a
            type 'a elt_ = elt
            type 'a set = t
            type ('a, 'b) result_ = 'a result
            val empty : 'a set
            val is_empty : 'a set -> bool
            val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
            val add : 'a elt_ -> 'a set -> 'a set
            val singleton : 'a elt_ -> 'a set
            val remove : 'a elt_ -> 'a set -> 'a set
            val min_elt : 'a set -> ('a elt_, 'a) result_
            val max_elt : 'a set -> ('a elt_, 'a) result_
            val choose : 'a set -> ('a elt_, 'a) result_
            val cardinal : 'a set -> int
            val compare : 'a set -> 'a set -> int
            val equal : 'a set -> 'a set -> bool
            val iter : ('a elt_ -> unit) -> 'a set -> unit
            val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
            val union : 'a set -> 'a set -> 'a set
            val inter : 'a set -> 'a set -> 'a set
            val diff : 'a set -> 'a set -> 'a set
            val gen1 :
              (?size:int -> Random.State.t -> 'a elt_) ->
              ?size:int -> Random.State.t -> 'a set
            val well_formed : 'a set -> bool
            val of_result : ('a, 'b) result_ -> 'a
            type 'a cursor_ = cursor
            val to_cursor : 'a set -> 'a cursor_
            val from_cursor : 'a cursor_ -> 'a set
            val at_top : 'a cursor_ -> bool
            val at_left : 'a cursor_ -> bool
            val at_right : 'a cursor_ -> bool
            val move_up : 'a cursor_ -> 'a cursor_
            val move_down_left : 'a cursor_ -> 'a cursor_
            val move_down_right : 'a cursor_ -> 'a cursor_
            val went_left : 'a cursor_ -> bool
            val went_right : 'a cursor_ -> bool
            val has_value : 'a cursor_ -> bool
            val get_value : 'a cursor_ -> 'a elt_
            val to_string : 'a set -> string
            val gen : ?size:int -> Random.State.t -> t
          end
      module type PolySetSig =
        sig
          type 'a t
          type 'a cursor
          type ('a, 'b) result
          type 'a elt_ = 'a
          type 'a set = 'a t
          type ('a, 'b) result_ = ('a, 'b) result
          val empty : 'a set
          val is_empty : 'a set -> bool
          val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
          val add : 'a elt_ -> 'a set -> 'a set
          val singleton : 'a elt_ -> 'a set
          val remove : 'a elt_ -> 'a set -> 'a set
          val min_elt : 'a set -> ('a elt_, 'a) result_
          val max_elt : 'a set -> ('a elt_, 'a) result_
          val choose : 'a set -> ('a elt_, 'a) result_
          val cardinal : 'a set -> int
          val compare : 'a set -> 'a set -> int
          val equal : 'a set -> 'a set -> bool
          val iter : ('a elt_ -> unit) -> 'a set -> unit
          val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
          val union : 'a set -> 'a set -> 'a set
          val inter : 'a set -> 'a set -> 'a set
          val diff : 'a set -> 'a set -> 'a set
          val gen1 :
            (?size:int -> Random.State.t -> 'a elt_) ->
            ?size:int -> Random.State.t -> 'a set
          val well_formed : 'a set -> bool
          val of_result : ('a, 'b) result_ -> 'a
          type 'a cursor_ = 'a cursor
          val to_cursor : 'a set -> 'a cursor_
          val from_cursor : 'a cursor_ -> 'a set
          val at_top : 'a cursor_ -> bool
          val at_left : 'a cursor_ -> bool
          val at_right : 'a cursor_ -> bool
          val move_up : 'a cursor_ -> 'a cursor_
          val move_down_left : 'a cursor_ -> 'a cursor_
          val move_down_right : 'a cursor_ -> 'a cursor_
          val went_left : 'a cursor_ -> bool
          val went_right : 'a cursor_ -> bool
          val has_value : 'a cursor_ -> bool
          val get_value : 'a cursor_ -> 'a elt_
          val to_string : ('-> string) -> 'a set -> string
        end
      module type PolySetSigStd =
        sig
          type 'a t
          type 'a cursor
          type ('a, 'b) result = 'a
          type 'a elt_ = 'a
          type 'a set = 'a t
          type ('a, 'b) result_ = ('a, 'b) result
          val empty : 'a set
          val is_empty : 'a set -> bool
          val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
          val add : 'a elt_ -> 'a set -> 'a set
          val singleton : 'a elt_ -> 'a set
          val remove : 'a elt_ -> 'a set -> 'a set
          val min_elt : 'a set -> ('a elt_, 'a) result_
          val max_elt : 'a set -> ('a elt_, 'a) result_
          val choose : 'a set -> ('a elt_, 'a) result_
          val cardinal : 'a set -> int
          val compare : 'a set -> 'a set -> int
          val equal : 'a set -> 'a set -> bool
          val iter : ('a elt_ -> unit) -> 'a set -> unit
          val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
          val union : 'a set -> 'a set -> 'a set
          val inter : 'a set -> 'a set -> 'a set
          val diff : 'a set -> 'a set -> 'a set
          val gen1 :
            (?size:int -> Random.State.t -> 'a elt_) ->
            ?size:int -> Random.State.t -> 'a set
          val well_formed : 'a set -> bool
          val of_result : ('a, 'b) result_ -> 'a
          type 'a cursor_ = 'a cursor
          val to_cursor : 'a set -> 'a cursor_
          val from_cursor : 'a cursor_ -> 'a set
          val at_top : 'a cursor_ -> bool
          val at_left : 'a cursor_ -> bool
          val at_right : 'a cursor_ -> bool
          val move_up : 'a cursor_ -> 'a cursor_
          val move_down_left : 'a cursor_ -> 'a cursor_
          val move_down_right : 'a cursor_ -> 'a cursor_
          val went_left : 'a cursor_ -> bool
          val went_right : 'a cursor_ -> bool
          val has_value : 'a cursor_ -> bool
          val get_value : 'a cursor_ -> 'a elt_
          val to_string : ('-> string) -> 'a set -> string
        end
    end
  module TreeSetIterator :
    sig
      module type S =
        sig
          type ordering = PreOrder | InOrder | PostOrder
          type direction_ =
              Ascending of Reins.TreeSetIterator.S.ordering
            | Descending of Reins.TreeSetIterator.S.ordering
          type 'a t
          type 'a elt
          type 'a cursor
          type 'a collection
          type direction = direction_
          type 'a traversal =
              Traverse_All
            | Traverse_If of ('-> bool)
            | Traverse_While of ('-> bool)
          val create : direction -> 'a elt traversal -> 'a collection -> 'a t
          val from_cursor :
            direction -> 'a elt traversal -> 'a cursor -> 'a t
          val value : 'a t -> 'a elt option
          val get_value : 'a t -> 'a elt
          val at_end : 'a t -> bool
          val at_beg : 'a t -> bool
          val has_next : 'a t -> bool
          val next : 'a t -> 'a t
          val has_prev : 'a t -> bool
          val prev : 'a t -> 'a t
          val goto_beg : 'a t -> 'a t
          val goto_end : 'a t -> 'a t
          val flip : 'a t -> 'a t
          val iter : ('a elt -> unit) -> 'a t -> unit
          val fold : ('-> 'b elt -> 'a) -> '-> 'b t -> 'a
        end
      module Make :
        functor (T : Sets.Set_->
          sig
            type ordering = PreOrder | InOrder | PostOrder
            type direction_ = Ascending of ordering | Descending of ordering
            type 'a t
            type 'a elt = 'T.elt_
            type 'a cursor = 'T.cursor_
            type 'a collection = 'T.set
            type direction = direction_
            type 'a traversal =
                Traverse_All
              | Traverse_If of ('-> bool)
              | Traverse_While of ('-> bool)
            val create :
              direction -> 'a elt traversal -> 'a collection -> 'a t
            val from_cursor :
              direction -> 'a elt traversal -> 'a cursor -> 'a t
            val value : 'a t -> 'a elt option
            val get_value : 'a t -> 'a elt
            val at_end : 'a t -> bool
            val at_beg : 'a t -> bool
            val has_next : 'a t -> bool
            val next : 'a t -> 'a t
            val has_prev : 'a t -> bool
            val prev : 'a t -> 'a t
            val goto_beg : 'a t -> 'a t
            val goto_end : 'a t -> 'a t
            val flip : 'a t -> 'a t
            val iter : ('a elt -> unit) -> 'a t -> unit
            val fold : ('-> 'b elt -> 'a) -> '-> 'b t -> 'a
          end
    end
  module CatenableList :
    sig
      type 'a t
      val empty : 'Reins.CatenableList.t
      val is_empty : 'Reins.CatenableList.t -> bool
      val length : 'Reins.CatenableList.t -> int
      val rev : 'Reins.CatenableList.t -> 'Reins.CatenableList.t
      val hd : 'Reins.CatenableList.t -> 'a
      val tl : 'Reins.CatenableList.t -> 'Reins.CatenableList.t
      val pop : 'Reins.CatenableList.t -> 'a * 'Reins.CatenableList.t
      val cons : '-> 'Reins.CatenableList.t -> 'Reins.CatenableList.t
      val snoc : '-> 'Reins.CatenableList.t -> 'Reins.CatenableList.t
      val last : 'Reins.CatenableList.t -> 'a
      val append :
        'Reins.CatenableList.t ->
        'Reins.CatenableList.t -> 'Reins.CatenableList.t
      val flatten :
        'Reins.CatenableList.t Reins.CatenableList.t ->
        'Reins.CatenableList.t
      val from_list : 'a list -> 'Reins.CatenableList.t
      val to_list : 'Reins.CatenableList.t -> 'a list
      val iter : ('-> unit) -> 'Reins.CatenableList.t -> unit
      val fold : ('-> '-> 'a) -> '-> 'Reins.CatenableList.t -> 'a
      val rev_map :
        ('-> 'b) -> 'Reins.CatenableList.t -> 'Reins.CatenableList.t
      val map :
        ('-> 'b) -> 'Reins.CatenableList.t -> 'Reins.CatenableList.t
      val to_string : ('-> string) -> 'Reins.CatenableList.t -> string
      val compare :
        ('-> '-> int) ->
        'Reins.CatenableList.t -> 'Reins.CatenableList.t -> int
      val gen :
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'Reins.CatenableList.t
    end
  module DoubleList :
    sig
      module Make :
        functor (L : Lists.ListSig->
          sig
            type 'a t
            val empty : 'Reins.DoubleList.Make.t
            val is_empty : 'Reins.DoubleList.Make.t -> bool
            val at_front : 'a t -> bool
            val at_back : 'a t -> bool
            val length : 'Reins.DoubleList.Make.t -> int
            val next_length : 'Reins.DoubleList.Make.t -> int
            val prev_length : 'Reins.DoubleList.Make.t -> int
            val rev :
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val hd : 'Reins.DoubleList.Make.t -> 'a
            val tl : 'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val pop :
              'Reins.DoubleList.Make.t -> 'a * 'Reins.DoubleList.Make.t
            val last : 'Reins.DoubleList.Make.t -> 'a
            val next :
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val prev_hd : 'Reins.DoubleList.Make.t -> 'a
            val prev_tl :
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val prev_pop :
              'Reins.DoubleList.Make.t -> 'a * 'Reins.DoubleList.Make.t
            val prev :
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val cons :
              '-> 'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val prev_cons :
              '-> 'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val snoc :
              '-> 'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val prev_snoc :
              '-> 'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val append :
              'Reins.DoubleList.Make.t ->
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val splice :
              'Reins.DoubleList.Make.t ->
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val flatten :
              'Reins.DoubleList.Make.t Reins.DoubleList.Make.t ->
              'Reins.DoubleList.Make.t
            val from_list : 'a list -> 'Reins.DoubleList.Make.t
            val to_list : 'Reins.DoubleList.Make.t -> 'a list
            val iter : ('-> unit) -> 'Reins.DoubleList.Make.t -> unit
            val fold :
              ('-> '-> 'a) -> '-> 'Reins.DoubleList.Make.t -> 'a
            val rev_map :
              ('-> 'b) ->
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val map :
              ('-> 'b) ->
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t
            val to_string :
              ('-> string) -> 'Reins.DoubleList.Make.t -> string
            val compare :
              ('-> '-> int) ->
              'Reins.DoubleList.Make.t -> 'Reins.DoubleList.Make.t -> int
            val gen :
              (?size:int -> Random.State.t -> 'a) ->
              ?size:int -> Random.State.t -> 'Reins.DoubleList.Make.t
            type 'a list_ = 'a t
            type 'a cursor = 'a t
            val to_cursor : 'a list_ -> 'a cursor
            val from_cursor : 'a cursor -> 'a list_
            val at_front : 'a cursor -> bool
            val at_back : 'a cursor -> bool
            val move_next : 'a cursor -> 'a cursor
            val move_prev : 'a cursor -> 'a cursor
            val goto_front : 'a cursor -> 'a cursor
            val goto_back : 'a cursor -> 'a cursor
            val value : 'a cursor -> 'a option
            val list : 'a cursor -> 'a list_
            val replace_list : 'a list_ -> 'a cursor -> 'a cursor
          end
    end
  module DoubleQueue :
    sig
      type 'a t
      val empty : 'Reins.DoubleQueue.t
      val is_empty : 'Reins.DoubleQueue.t -> bool
      val hd : 'Reins.DoubleQueue.t -> 'a
      val tl : 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val pop : 'Reins.DoubleQueue.t -> 'a * 'Reins.DoubleQueue.t
      val cons : '-> 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val hd_back : 'Reins.DoubleQueue.t -> 'a
      val tl_back : 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val pop_back : 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t * 'a
      val cons_back : '-> 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val snoc : '-> 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val last : 'Reins.DoubleQueue.t -> 'a
      val enqueue : '-> 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val dequeue : 'Reins.DoubleQueue.t -> 'a * 'Reins.DoubleQueue.t
      val length : 'Reins.DoubleQueue.t -> int
      val rev : 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val append :
        'Reins.DoubleQueue.t ->
        'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val iter : ('-> unit) -> 'Reins.DoubleQueue.t -> unit
      val fold : ('-> '-> 'a) -> '-> 'Reins.DoubleQueue.t -> 'a
      val rev_map :
        ('-> 'b) -> 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val map :
        ('-> 'b) -> 'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val to_list : 'Reins.DoubleQueue.t -> 'a list
      val from_list : 'a list -> 'Reins.DoubleQueue.t
      val flatten :
        'Reins.DoubleQueue.t Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t
      val to_string : ('-> string) -> 'Reins.DoubleQueue.t -> string
      val compare :
        ('-> '-> int) ->
        'Reins.DoubleQueue.t -> 'Reins.DoubleQueue.t -> int
      val gen :
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'Reins.DoubleQueue.t
    end
  module SList :
    sig
      type 'a t = 'a list
      val empty : 'a list
      val is_empty : 'a list -> bool
      val cons : '-> 'a list -> 'a list
      val pop : 'a list -> 'a * 'a list
      val fold : ('-> '-> 'a) -> '-> 'b list -> 'a
      val snoc : '-> 'a list -> 'a list
      val last : 'Reins.SList.t -> 'a
      val to_list : '-> 'a
      val from_list : '-> 'a
      val to_string : ('-> string) -> 'a list -> string
      val compare : ('-> '-> int) -> 'a list -> 'b list -> int
      val gen :
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'a list
      val length : 'a list -> int
      val hd : 'a list -> 'a
      val tl : 'a list -> 'a list
      val nth : 'a list -> int -> 'a
      val rev : 'a list -> 'a list
      val append : 'a list -> 'a list -> 'a list
      val rev_append : 'a list -> 'a list -> 'a list
      val concat : 'a list list -> 'a list
      val flatten : 'a list list -> 'a list
      val iter : ('-> unit) -> 'a list -> unit
      val map : ('-> 'b) -> 'a list -> 'b list
      val rev_map : ('-> 'b) -> 'a list -> 'b list
      val fold_left : ('-> '-> 'a) -> '-> 'b list -> 'a
      val fold_right : ('-> '-> 'b) -> 'a list -> '-> 'b
      val iter2 : ('-> '-> unit) -> 'a list -> 'b list -> unit
      val map2 : ('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val rev_map2 : ('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val fold_left2 :
        ('-> '-> '-> 'a) -> '-> 'b list -> 'c list -> 'a
      val fold_right2 :
        ('-> '-> '-> 'c) -> 'a list -> 'b list -> '-> 'c
      val for_all : ('-> bool) -> 'a list -> bool
      val exists : ('-> bool) -> 'a list -> bool
      val for_all2 : ('-> '-> bool) -> 'a list -> 'b list -> bool
      val exists2 : ('-> '-> bool) -> 'a list -> 'b list -> bool
      val mem : '-> 'a list -> bool
      val memq : '-> 'a list -> bool
      val find : ('-> bool) -> 'a list -> 'a
      val filter : ('-> bool) -> 'a list -> 'a list
      val find_all : ('-> bool) -> 'a list -> 'a list
      val partition : ('-> bool) -> 'a list -> 'a list * 'a list
      val assoc : '-> ('a * 'b) list -> 'b
      val assq : '-> ('a * 'b) list -> 'b
      val mem_assoc : '-> ('a * 'b) list -> bool
      val mem_assq : '-> ('a * 'b) list -> bool
      val remove_assoc : '-> ('a * 'b) list -> ('a * 'b) list
      val remove_assq : '-> ('a * 'b) list -> ('a * 'b) list
      val split : ('a * 'b) list -> 'a list * 'b list
      val combine : 'a list -> 'b list -> ('a * 'b) list
      val sort : ('-> '-> int) -> 'a list -> 'a list
      val stable_sort : ('-> '-> int) -> 'a list -> 'a list
      val fast_sort : ('-> '-> int) -> 'a list -> 'a list
      val merge : ('-> '-> int) -> 'a list -> 'a list -> 'a list
    end
  module SkewBinaryList :
    sig
      type 'a t
      val empty : 'Reins.SkewBinaryList.t
      val is_empty : 'Reins.SkewBinaryList.t -> bool
      val length : 'Reins.SkewBinaryList.t -> int
      val rev : 'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
      val cons : '-> 'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
      val snoc : '-> 'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
      val last : 'Reins.SkewBinaryList.t -> 'a
      val hd : 'Reins.SkewBinaryList.t -> 'a
      val tl : 'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
      val pop : 'Reins.SkewBinaryList.t -> 'a * 'Reins.SkewBinaryList.t
      val append :
        'Reins.SkewBinaryList.t ->
        'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
      val flatten :
        'Reins.SkewBinaryList.t Reins.SkewBinaryList.t ->
        'Reins.SkewBinaryList.t
      val from_list : 'a list -> 'Reins.SkewBinaryList.t
      val to_list : 'Reins.SkewBinaryList.t -> 'a list
      val iter : ('-> unit) -> 'Reins.SkewBinaryList.t -> unit
      val fold : ('-> '-> 'a) -> '-> 'Reins.SkewBinaryList.t -> 'a
      val rev_map :
        ('-> 'b) -> 'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
      val map :
        ('-> 'b) -> 'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
      val to_string : ('-> string) -> 'Reins.SkewBinaryList.t -> string
      val compare :
        ('-> '-> int) ->
        'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t -> int
      val gen :
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'Reins.SkewBinaryList.t
      val lookup : int -> 'Reins.SkewBinaryList.t -> 'a
      val update :
        int -> '-> 'Reins.SkewBinaryList.t -> 'Reins.SkewBinaryList.t
    end
  module Maps :
    sig
      module type Map_ =
        sig
          type 'a key_
          type 'a elt_
          type ('a, 'b) map
          type ('a, 'b, 'c) result_
          val empty : ('a, 'b) Reins.Maps.Map_.map
          val is_empty : ('a, 'b) Reins.Maps.Map_.map -> bool
          val mem :
            'Reins.Maps.Map_.key_ ->
            ('a, 'b) Reins.Maps.Map_.map ->
            (bool, 'a, 'b) Reins.Maps.Map_.result_
          val add :
            'Reins.Maps.Map_.key_ ->
            'Reins.Maps.Map_.elt_ ->
            ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
          val singleton :
            'Reins.Maps.Map_.key_ ->
            'Reins.Maps.Map_.elt_ -> ('a, 'b) Reins.Maps.Map_.map
          val remove :
            'Reins.Maps.Map_.key_ ->
            ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
          val find :
            'Reins.Maps.Map_.key_ ->
            ('a, 'b) Reins.Maps.Map_.map ->
            ('Reins.Maps.Map_.elt_, 'a, 'b) Reins.Maps.Map_.result_
          val min_key :
            ('a, 'b) Reins.Maps.Map_.map ->
            ('Reins.Maps.Map_.key_, 'a, 'b) Reins.Maps.Map_.result_
          val max_key :
            ('a, 'b) Reins.Maps.Map_.map ->
            ('Reins.Maps.Map_.key_, 'a, 'b) Reins.Maps.Map_.result_
          val min_keyval :
            ('a, 'b) Reins.Maps.Map_.map ->
            ('Reins.Maps.Map_.key_ * 'Reins.Maps.Map_.elt_, 'a, 'b)
            Reins.Maps.Map_.result_
          val max_keyval :
            ('a, 'b) Reins.Maps.Map_.map ->
            ('Reins.Maps.Map_.key_ * 'Reins.Maps.Map_.elt_, 'a, 'b)
            Reins.Maps.Map_.result_
          val cardinal : ('a, 'b) Reins.Maps.Map_.map -> int
          val iter :
            ('Reins.Maps.Map_.key_ -> 'Reins.Maps.Map_.elt_ -> unit) ->
            ('a, 'b) Reins.Maps.Map_.map -> unit
          val fold :
            ('-> 'Reins.Maps.Map_.key_ -> 'Reins.Maps.Map_.elt_ -> 'a) ->
            '-> ('b, 'c) Reins.Maps.Map_.map -> 'a
          val map :
            ('Reins.Maps.Map_.elt_ -> 'Reins.Maps.Map_.elt_) ->
            ('c, 'a) Reins.Maps.Map_.map -> ('c, 'b) Reins.Maps.Map_.map
          val mapi :
            ('Reins.Maps.Map_.key_ ->
             'Reins.Maps.Map_.elt_ -> 'Reins.Maps.Map_.elt_) ->
            ('a, 'b) Reins.Maps.Map_.map -> ('a, 'c) Reins.Maps.Map_.map
          val union :
            ('Reins.Maps.Map_.key_ ->
             'Reins.Maps.Map_.elt_ ->
             'Reins.Maps.Map_.elt_ -> 'Reins.Maps.Map_.elt_) ->
            ('a, 'b) Reins.Maps.Map_.map ->
            ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
          val inter :
            ('Reins.Maps.Map_.key_ ->
             'Reins.Maps.Map_.elt_ ->
             'Reins.Maps.Map_.elt_ -> 'Reins.Maps.Map_.elt_) ->
            ('a, 'b) Reins.Maps.Map_.map ->
            ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
          val diff :
            ('Reins.Maps.Map_.key_ ->
             'Reins.Maps.Map_.elt_ -> 'Reins.Maps.Map_.elt_ -> bool) ->
            ('a, 'b) Reins.Maps.Map_.map ->
            ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
          val well_formed : ('a, 'b) Reins.Maps.Map_.map -> bool
          val of_result : ('a, 'b, 'c) Reins.Maps.Map_.result_ -> 'a
          type ('a, 'b) cursor_
          val to_cursor :
            ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.cursor_
          val from_cursor :
            ('a, 'b) Reins.Maps.Map_.cursor_ -> ('a, 'b) Reins.Maps.Map_.map
          val at_top : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
          val at_left : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
          val at_right : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
          val move_up :
            ('a, 'b) Reins.Maps.Map_.cursor_ ->
            ('a, 'b) Reins.Maps.Map_.cursor_
          val move_down_left :
            ('a, 'b) Reins.Maps.Map_.cursor_ ->
            ('a, 'b) Reins.Maps.Map_.cursor_
          val move_down_right :
            ('a, 'b) Reins.Maps.Map_.cursor_ ->
            ('a, 'b) Reins.Maps.Map_.cursor_
          val went_left : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
          val went_right : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
          val has_value : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
          val get_value :
            ('a, 'b) Reins.Maps.Map_.cursor_ ->
            'Reins.Maps.Map_.key_ * 'Reins.Maps.Map_.elt_
        end
      module type PolyMapSig =
        sig
          type ('a, 'b) t
          type 'a key = 'a
          type 'a elt = 'a
          type ('a, 'b) cursor
          type ('a, 'b, 'c) result
          type 'a key_ = 'a
          type 'a elt_ = 'a
          type ('a, 'b) map = ('a, 'b) t
          type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = ('a, 'b) cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val gen2 :
            (?size:int -> Random.State.t -> 'a key_) ->
            (?size:int -> Random.State.t -> 'b elt_) ->
            ?size:int -> Random.State.t -> ('a, 'b) map
          val to_string : ('-> '-> string) -> ('a, 'b) map -> string
          val compare :
            ('-> '-> int) ->
            ('-> '-> int) ->
            ('a, 'b) Reins.Maps.PolyMapSig.t ->
            ('a, 'b) Reins.Maps.PolyMapSig.t -> int
          val compare_keys :
            ('-> '-> int) ->
            ('a, 'b) Reins.Maps.PolyMapSig.t ->
            ('a, 'b) Reins.Maps.PolyMapSig.t -> int
        end
      module type PolyMapSigStd =
        sig
          type ('a, 'b) t
          type 'a key = 'a
          type 'a elt = 'a
          type ('a, 'b) cursor
          type ('a, 'b, 'c) result = 'a
          type 'a key_ = 'a
          type 'a elt_ = 'a
          type ('a, 'b) map = ('a, 'b) t
          type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = ('a, 'b) cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val gen2 :
            (?size:int -> Random.State.t -> 'a key_) ->
            (?size:int -> Random.State.t -> 'b elt_) ->
            ?size:int -> Random.State.t -> ('a, 'b) map
          val to_string : ('-> '-> string) -> ('a, 'b) map -> string
          val compare :
            ('-> '-> int) ->
            ('-> '-> int) -> ('a, 'b) t -> ('a, 'b) t -> int
          val compare_keys :
            ('-> '-> int) -> ('a, 'b) t -> ('a, 'b) t -> int
        end
      module type MonoKeyMapSig =
        sig
          type 'a t
          type key
          type 'a elt = 'a
          type 'a cursor
          type ('a, 'b) result
          type 'a key_ = key
          type 'a elt_ = 'a
          type ('a, 'b) map = 'b t
          type ('a, 'b, 'c) result_ = ('a, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = 'b cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys :
            'Reins.Maps.MonoKeyMapSig.t ->
            'Reins.Maps.MonoKeyMapSig.t -> int
          val compare :
            ('-> '-> int) ->
            'Reins.Maps.MonoKeyMapSig.t ->
            'Reins.Maps.MonoKeyMapSig.t -> int
          val to_string :
            ('-> string) -> 'Reins.Maps.MonoKeyMapSig.t -> string
          val gen2 :
            (?size:int -> Random.State.t -> Reins.Maps.MonoKeyMapSig.key) ->
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'Reins.Maps.MonoKeyMapSig.t
        end
      module type MonoKeyMapSigStd =
        sig
          type 'a t
          type key
          type 'a elt = 'a
          type 'a cursor
          type ('a, 'b) result = 'a
          type 'a key_ = key
          type 'a elt_ = 'a
          type ('a, 'b) map = 'b t
          type ('a, 'b, 'c) result_ = ('a, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = 'b cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : 'a t -> 'a t -> int
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val to_string : ('-> string) -> 'a t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
        end
      module type MonoKeyMapSigFnStd =
        functor (C : Types.Mono.Comparable->
          sig
            type 'a t
            type key = C.t
            type 'a elt = 'a
            type 'a cursor
            type ('a, 'b) result = 'a
            type 'a key_ = key
            type 'a elt_ = 'a
            type ('a, 'b) map = 'b t
            type ('a, 'b, 'c) result_ = ('a, 'c) result
            val empty : ('a, 'b) map
            val is_empty : ('a, 'b) map -> bool
            val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
            val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
            val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
            val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
            val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
            val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val min_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val max_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val cardinal : ('a, 'b) map -> int
            val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
            val fold :
              ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
            val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
            val mapi :
              ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
            val union :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val inter :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val diff :
              ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val well_formed : ('a, 'b) map -> bool
            val of_result : ('a, 'b, 'c) result_ -> 'a
            type ('a, 'b) cursor_ = 'b cursor
            val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
            val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
            val at_top : ('a, 'b) cursor_ -> bool
            val at_left : ('a, 'b) cursor_ -> bool
            val at_right : ('a, 'b) cursor_ -> bool
            val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val went_left : ('a, 'b) cursor_ -> bool
            val went_right : ('a, 'b) cursor_ -> bool
            val has_value : ('a, 'b) cursor_ -> bool
            val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
            val compare_keys : 'a t -> 'a t -> int
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val to_string : ('-> string) -> 'a t -> string
            val gen2 :
              (?size:int -> Random.State.t -> key) ->
              (?size:int -> Random.State.t -> 'a) ->
              ?size:int -> Random.State.t -> 'a t
          end
      module type GenKeyMapSig =
        sig
          type 'a t
          type key
          type 'a elt = 'a
          type 'a cursor
          type ('a, 'b) result
          type 'a key_ = key
          type 'a elt_ = 'a
          type ('a, 'b) map = 'b t
          type ('a, 'b, 'c) result_ = ('a, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = 'b cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : 'a t -> 'a t -> int
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val to_string : ('-> string) -> 'a t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
          val gen1 :
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
        end
      module type GenKeyMapSigStd =
        sig
          type 'a t
          type key
          type 'a elt = 'a
          type 'a cursor
          type ('a, 'b) result = 'a
          type 'a key_ = key
          type 'a elt_ = 'a
          type ('a, 'b) map = 'b t
          type ('a, 'b, 'c) result_ = ('a, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = 'b cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : 'a t -> 'a t -> int
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val to_string : ('-> string) -> 'a t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
          val gen1 :
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
        end
      module type GenKeyMapSigFnStd =
        functor (C : Types.Mono.ArbitraryComparable->
          sig
            type 'a t
            type key = C.t
            type 'a elt = 'a
            type 'a cursor
            type ('a, 'b) result = 'a
            type 'a key_ = key
            type 'a elt_ = 'a
            type ('a, 'b) map = 'b t
            type ('a, 'b, 'c) result_ = ('a, 'c) result
            val empty : ('a, 'b) map
            val is_empty : ('a, 'b) map -> bool
            val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
            val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
            val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
            val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
            val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
            val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val min_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val max_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val cardinal : ('a, 'b) map -> int
            val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
            val fold :
              ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
            val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
            val mapi :
              ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
            val union :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val inter :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val diff :
              ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val well_formed : ('a, 'b) map -> bool
            val of_result : ('a, 'b, 'c) result_ -> 'a
            type ('a, 'b) cursor_ = 'b cursor
            val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
            val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
            val at_top : ('a, 'b) cursor_ -> bool
            val at_left : ('a, 'b) cursor_ -> bool
            val at_right : ('a, 'b) cursor_ -> bool
            val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val went_left : ('a, 'b) cursor_ -> bool
            val went_right : ('a, 'b) cursor_ -> bool
            val has_value : ('a, 'b) cursor_ -> bool
            val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
            val compare_keys : 'a t -> 'a t -> int
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val to_string : ('-> string) -> 'a t -> string
            val gen2 :
              (?size:int -> Random.State.t -> key) ->
              (?size:int -> Random.State.t -> 'a) ->
              ?size:int -> Random.State.t -> 'a t
            val gen1 :
              (?size:int -> Random.State.t -> 'a) ->
              ?size:int -> Random.State.t -> 'a t
          end
      module type MonoMapSig =
        sig
          type t
          type key
          type elt
          type cursor
          type 'a result
          type 'a key_ = key
          type 'a elt_ = elt
          type ('a, 'b) map = t
          type ('a, 'b, 'c) result_ = 'a result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys :
            Reins.Maps.MonoMapSig.t -> Reins.Maps.MonoMapSig.t -> int
          val compare :
            Reins.Maps.MonoMapSig.t -> Reins.Maps.MonoMapSig.t -> int
          val to_string : Reins.Maps.MonoMapSig.t -> string
          val gen2 :
            (?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.key) ->
            (?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.elt) ->
            ?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.t
        end
      module type MonoMapSigFn =
        functor (K : Types.Mono.Comparable->
          functor (V : Types.Mono.Comparable->
            sig
              type t
              type key = K.t
              type elt = V.t
              type cursor
              type 'a result
              type 'a key_ = key
              type 'a elt_ = elt
              type ('a, 'b) map = t
              type ('a, 'b, 'c) result_ = 'a result
              val empty : ('a, 'b) map
              val is_empty : ('a, 'b) map -> bool
              val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
              val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
              val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
              val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
              val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
              val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val min_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val max_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val cardinal : ('a, 'b) map -> int
              val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
              val fold :
                ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
              val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
              val mapi :
                ('a key_ -> 'b elt_ -> 'c elt_) ->
                ('a, 'b) map -> ('a, 'c) map
              val union :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val inter :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val diff :
                ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val well_formed : ('a, 'b) map -> bool
              val of_result : ('a, 'b, 'c) result_ -> 'a
              type ('a, 'b) cursor_ = cursor
              val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
              val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
              val at_top : ('a, 'b) cursor_ -> bool
              val at_left : ('a, 'b) cursor_ -> bool
              val at_right : ('a, 'b) cursor_ -> bool
              val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val went_left : ('a, 'b) cursor_ -> bool
              val went_right : ('a, 'b) cursor_ -> bool
              val has_value : ('a, 'b) cursor_ -> bool
              val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
              val compare_keys : t -> t -> int
              val compare : t -> t -> int
              val to_string : t -> string
              val gen2 :
                (?size:int -> Random.State.t -> key) ->
                (?size:int -> Random.State.t -> elt) ->
                ?size:int -> Random.State.t -> t
            end
      module type MonoMapSigFnStd =
        functor (K : Types.Mono.Comparable->
          functor (V : Types.Mono.Comparable->
            sig
              type t
              type key = K.t
              type elt = V.t
              type cursor
              type 'a result = 'a
              type 'a key_ = key
              type 'a elt_ = elt
              type ('a, 'b) map = t
              type ('a, 'b, 'c) result_ = 'a result
              val empty : ('a, 'b) map
              val is_empty : ('a, 'b) map -> bool
              val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
              val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
              val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
              val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
              val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
              val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val min_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val max_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val cardinal : ('a, 'b) map -> int
              val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
              val fold :
                ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
              val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
              val mapi :
                ('a key_ -> 'b elt_ -> 'c elt_) ->
                ('a, 'b) map -> ('a, 'c) map
              val union :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val inter :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val diff :
                ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val well_formed : ('a, 'b) map -> bool
              val of_result : ('a, 'b, 'c) result_ -> 'a
              type ('a, 'b) cursor_ = cursor
              val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
              val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
              val at_top : ('a, 'b) cursor_ -> bool
              val at_left : ('a, 'b) cursor_ -> bool
              val at_right : ('a, 'b) cursor_ -> bool
              val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val went_left : ('a, 'b) cursor_ -> bool
              val went_right : ('a, 'b) cursor_ -> bool
              val has_value : ('a, 'b) cursor_ -> bool
              val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
              val compare_keys : t -> t -> int
              val compare : t -> t -> int
              val to_string : t -> string
              val gen2 :
                (?size:int -> Random.State.t -> key) ->
                (?size:int -> Random.State.t -> elt) ->
                ?size:int -> Random.State.t -> t
            end
      module type GenMapSig =
        sig
          type t
          type key
          type elt
          type cursor
          type 'a result
          type 'a key_ = key
          type 'a elt_ = elt
          type ('a, 'b) map = t
          type ('a, 'b, 'c) result_ = 'a result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : t -> t -> int
          val compare : t -> t -> int
          val to_string : t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> elt) ->
            ?size:int -> Random.State.t -> t
          val gen : ?size:int -> Random.State.t -> t
        end
      module type GenMapSigFn =
        functor (K : Types.Mono.ArbitraryComparable->
          functor (V : Types.Mono.ArbitraryComparable->
            sig
              type t
              type key = K.t
              type elt = V.t
              type cursor
              type 'a result
              type 'a key_ = key
              type 'a elt_ = elt
              type ('a, 'b) map = t
              type ('a, 'b, 'c) result_ = 'a result
              val empty : ('a, 'b) map
              val is_empty : ('a, 'b) map -> bool
              val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
              val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
              val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
              val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
              val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
              val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val min_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val max_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val cardinal : ('a, 'b) map -> int
              val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
              val fold :
                ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
              val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
              val mapi :
                ('a key_ -> 'b elt_ -> 'c elt_) ->
                ('a, 'b) map -> ('a, 'c) map
              val union :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val inter :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val diff :
                ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val well_formed : ('a, 'b) map -> bool
              val of_result : ('a, 'b, 'c) result_ -> 'a
              type ('a, 'b) cursor_ = cursor
              val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
              val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
              val at_top : ('a, 'b) cursor_ -> bool
              val at_left : ('a, 'b) cursor_ -> bool
              val at_right : ('a, 'b) cursor_ -> bool
              val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val went_left : ('a, 'b) cursor_ -> bool
              val went_right : ('a, 'b) cursor_ -> bool
              val has_value : ('a, 'b) cursor_ -> bool
              val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
              val compare_keys : t -> t -> int
              val compare : t -> t -> int
              val to_string : t -> string
              val gen2 :
                (?size:int -> Random.State.t -> key) ->
                (?size:int -> Random.State.t -> elt) ->
                ?size:int -> Random.State.t -> t
              val gen : ?size:int -> Random.State.t -> t
            end
      module type GenMapSigFnStd =
        functor (K : Types.Mono.ArbitraryComparable->
          functor (V : Types.Mono.ArbitraryComparable->
            sig
              type t
              type key = K.t
              type elt = V.t
              type cursor
              type 'a result = 'a
              type 'a key_ = key
              type 'a elt_ = elt
              type ('a, 'b) map = t
              type ('a, 'b, 'c) result_ = 'a result
              val empty : ('a, 'b) map
              val is_empty : ('a, 'b) map -> bool
              val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
              val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
              val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
              val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
              val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
              val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val min_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val max_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val cardinal : ('a, 'b) map -> int
              val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
              val fold :
                ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
              val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
              val mapi :
                ('a key_ -> 'b elt_ -> 'c elt_) ->
                ('a, 'b) map -> ('a, 'c) map
              val union :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val inter :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val diff :
                ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val well_formed : ('a, 'b) map -> bool
              val of_result : ('a, 'b, 'c) result_ -> 'a
              type ('a, 'b) cursor_ = cursor
              val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
              val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
              val at_top : ('a, 'b) cursor_ -> bool
              val at_left : ('a, 'b) cursor_ -> bool
              val at_right : ('a, 'b) cursor_ -> bool
              val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val went_left : ('a, 'b) cursor_ -> bool
              val went_right : ('a, 'b) cursor_ -> bool
              val has_value : ('a, 'b) cursor_ -> bool
              val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
              val compare_keys : t -> t -> int
              val compare : t -> t -> int
              val to_string : t -> string
              val gen2 :
                (?size:int -> Random.State.t -> key) ->
                (?size:int -> Random.State.t -> elt) ->
                ?size:int -> Random.State.t -> t
              val gen : ?size:int -> Random.State.t -> t
            end
    end
  module AVLMap :
    sig
      module PolyMap : Maps.PolyMapSigStd
      module MonoKeyMap : Maps.MonoKeyMapSigFnStd
      module GenKeyMap : Maps.GenKeyMapSigFnStd
      module MonoMap : Maps.MonoMapSigFnStd
      module GenMap : Maps.GenMapSigFnStd
      module AVL_PMap :
        functor (HeightDiff : sig val v : int end-> Maps.PolyMapSig
      module AVL_KeyMap :
        functor (HeightDiff : sig val v : int end-> Maps.MonoKeyMapSigFnStd
      module AVL_GenKeyMap :
        functor (HeightDiff : sig val v : int end-> Maps.GenKeyMapSigFnStd
      module AVL_Map :
        functor (HeightDiff : sig val v : int end-> Maps.MonoMapSigFnStd
      module AVL_GenMap :
        functor (HeightDiff : sig val v : int end-> Maps.GenMapSigFnStd
      module Poly1 : Maps.PolyMapSig
      module Poly2 : Maps.PolyMapSig
      module Poly3 : Maps.PolyMapSig
      module MonoKey1 : Maps.MonoKeyMapSigFnStd
      module MonoKey2 : Maps.MonoKeyMapSigFnStd
      module MonoKey3 : Maps.MonoKeyMapSigFnStd
      module GenKey1 : Maps.GenKeyMapSigFnStd
      module GenKey2 : Maps.GenKeyMapSigFnStd
      module GenKey3 : Maps.GenKeyMapSigFnStd
      module Mono1 : Maps.MonoMapSigFnStd
      module Mono2 : Maps.MonoMapSigFnStd
      module Mono3 : Maps.MonoMapSigFnStd
      module Gen1 : Maps.GenMapSigFnStd
      module Gen2 : Maps.GenMapSigFnStd
      module Gen3 : Maps.GenMapSigFnStd
    end
  module PatriciaMap :
    sig
      module MonoKeyMap :
        sig
          type 'a t
          type key = int
          type 'a elt = 'a
          type 'a cursor
          type ('a, 'b) result
          type 'a key_ = key
          type 'a elt_ = 'a
          type ('a, 'b) map = 'b t
          type ('a, 'b, 'c) result_ = ('a, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = 'b cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : 'a t -> 'a t -> int
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val to_string : ('-> string) -> 'a t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
        end
      module GenKeyMap :
        sig
          type 'a t
          type key = int
          type 'a elt = 'a
          type 'a cursor
          type ('a, 'b) result
          type 'a key_ = key
          type 'a elt_ = 'a
          type ('a, 'b) map = 'b t
          type ('a, 'b, 'c) result_ = ('a, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = 'b cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : 'a t -> 'a t -> int
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val to_string : ('-> string) -> 'a t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
          val gen1 :
            (?size:int -> Random.State.t -> 'a) ->
            ?size:int -> Random.State.t -> 'a t
        end
      module MonoMap :
        functor (C : Types.Mono.Comparable->
          sig
            type t
            type key = int
            type elt = C.t
            type cursor
            type 'a result
            type 'a key_ = key
            type 'a elt_ = elt
            type ('a, 'b) map = t
            type ('a, 'b, 'c) result_ = 'a result
            val empty : ('a, 'b) map
            val is_empty : ('a, 'b) map -> bool
            val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
            val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
            val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
            val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
            val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
            val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val min_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val max_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val cardinal : ('a, 'b) map -> int
            val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
            val fold :
              ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
            val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
            val mapi :
              ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
            val union :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val inter :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val diff :
              ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val well_formed : ('a, 'b) map -> bool
            val of_result : ('a, 'b, 'c) result_ -> 'a
            type ('a, 'b) cursor_ = cursor
            val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
            val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
            val at_top : ('a, 'b) cursor_ -> bool
            val at_left : ('a, 'b) cursor_ -> bool
            val at_right : ('a, 'b) cursor_ -> bool
            val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val went_left : ('a, 'b) cursor_ -> bool
            val went_right : ('a, 'b) cursor_ -> bool
            val has_value : ('a, 'b) cursor_ -> bool
            val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
            val compare_keys : t -> t -> int
            val compare : t -> t -> int
            val to_string : t -> string
            val gen2 :
              (?size:int -> Random.State.t -> key) ->
              (?size:int -> Random.State.t -> elt) ->
              ?size:int -> Random.State.t -> t
          end
      module GenMap :
        functor (C : Types.Mono.ArbitraryComparable->
          sig
            type t
            type key = int
            type elt = C.t
            type cursor
            type 'a result
            type 'a key_ = key
            type 'a elt_ = elt
            type ('a, 'b) map = t
            type ('a, 'b, 'c) result_ = 'a result
            val empty : ('a, 'b) map
            val is_empty : ('a, 'b) map -> bool
            val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
            val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
            val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
            val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
            val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
            val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val min_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val max_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val cardinal : ('a, 'b) map -> int
            val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
            val fold :
              ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
            val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
            val mapi :
              ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
            val union :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val inter :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val diff :
              ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val well_formed : ('a, 'b) map -> bool
            val of_result : ('a, 'b, 'c) result_ -> 'a
            type ('a, 'b) cursor_ = cursor
            val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
            val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
            val at_top : ('a, 'b) cursor_ -> bool
            val at_left : ('a, 'b) cursor_ -> bool
            val at_right : ('a, 'b) cursor_ -> bool
            val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val went_left : ('a, 'b) cursor_ -> bool
            val went_right : ('a, 'b) cursor_ -> bool
            val has_value : ('a, 'b) cursor_ -> bool
            val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
            val compare_keys : t -> t -> int
            val compare : t -> t -> int
            val to_string : t -> string
            val gen2 :
              (?size:int -> Random.State.t -> key) ->
              (?size:int -> Random.State.t -> elt) ->
              ?size:int -> Random.State.t -> t
            val gen : ?size:int -> Random.State.t -> t
          end
    end
  module RBMap :
    sig
      module PolyMap : Maps.PolyMapSig
      module MonoKeyMap : Maps.MonoKeyMapSigFnStd
      module GenKeyMap : Maps.GenKeyMapSigFnStd
      module MonoMap : Maps.MonoMapSigFnStd
      module GenMap : Maps.GenMapSigFnStd
    end
  module SplayMap :
    sig
      module rec PolyMap :
        sig
          type ('a, 'b) t
          type 'a key = 'a
          type 'a elt = 'a
          type ('a, 'b) cursor
          type ('a, 'b, 'c) result = 'a * ('b, 'c) PolyMap.t
          type 'a key_ = 'a
          type 'a elt_ = 'a
          type ('a, 'b) map = ('a, 'b) t
          type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = ('a, 'b) cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val gen2 :
            (?size:int -> Random.State.t -> 'a key_) ->
            (?size:int -> Random.State.t -> 'b elt_) ->
            ?size:int -> Random.State.t -> ('a, 'b) map
          val to_string : ('-> '-> string) -> ('a, 'b) map -> string
          val compare :
            ('-> '-> int) ->
            ('-> '-> int) -> ('a, 'b) t -> ('a, 'b) t -> int
          val compare_keys :
            ('-> '-> int) -> ('a, 'b) t -> ('a, 'b) t -> int
        end
      module rec MonoKeyMap :
        functor (C : Types.Mono.Comparable->
          sig
            type 'a t
            type key = C.t
            type 'a elt = 'a
            type 'a cursor
            type ('a, 'b) result = 'a * 'MonoKeyMap(C).t
            type 'a key_ = key
            type 'a elt_ = 'a
            type ('a, 'b) map = 'b t
            type ('a, 'b, 'c) result_ = ('a, 'c) result
            val empty : ('a, 'b) map
            val is_empty : ('a, 'b) map -> bool
            val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
            val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
            val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
            val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
            val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
            val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val min_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val max_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val cardinal : ('a, 'b) map -> int
            val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
            val fold :
              ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
            val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
            val mapi :
              ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
            val union :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val inter :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val diff :
              ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val well_formed : ('a, 'b) map -> bool
            val of_result : ('a, 'b, 'c) result_ -> 'a
            type ('a, 'b) cursor_ = 'b cursor
            val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
            val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
            val at_top : ('a, 'b) cursor_ -> bool
            val at_left : ('a, 'b) cursor_ -> bool
            val at_right : ('a, 'b) cursor_ -> bool
            val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val went_left : ('a, 'b) cursor_ -> bool
            val went_right : ('a, 'b) cursor_ -> bool
            val has_value : ('a, 'b) cursor_ -> bool
            val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
            val compare_keys : 'a t -> 'a t -> int
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val to_string : ('-> string) -> 'a t -> string
            val gen2 :
              (?size:int -> Random.State.t -> key) ->
              (?size:int -> Random.State.t -> 'a) ->
              ?size:int -> Random.State.t -> 'a t
          end
      module rec GenKeyMap :
        functor (C : Types.Mono.ArbitraryComparable->
          sig
            type 'a t
            type key = C.t
            type 'a elt = 'a
            type 'a cursor
            type ('a, 'b) result = 'a * 'GenKeyMap(C).t
            type 'a key_ = key
            type 'a elt_ = 'a
            type ('a, 'b) map = 'b t
            type ('a, 'b, 'c) result_ = ('a, 'c) result
            val empty : ('a, 'b) map
            val is_empty : ('a, 'b) map -> bool
            val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
            val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
            val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
            val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
            val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
            val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
            val min_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val max_keyval :
              ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
            val cardinal : ('a, 'b) map -> int
            val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
            val fold :
              ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
            val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
            val mapi :
              ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
            val union :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val inter :
              ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val diff :
              ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
              ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
            val well_formed : ('a, 'b) map -> bool
            val of_result : ('a, 'b, 'c) result_ -> 'a
            type ('a, 'b) cursor_ = 'b cursor
            val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
            val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
            val at_top : ('a, 'b) cursor_ -> bool
            val at_left : ('a, 'b) cursor_ -> bool
            val at_right : ('a, 'b) cursor_ -> bool
            val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
            val went_left : ('a, 'b) cursor_ -> bool
            val went_right : ('a, 'b) cursor_ -> bool
            val has_value : ('a, 'b) cursor_ -> bool
            val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
            val compare_keys : 'a t -> 'a t -> int
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val to_string : ('-> string) -> 'a t -> string
            val gen2 :
              (?size:int -> Random.State.t -> key) ->
              (?size:int -> Random.State.t -> 'a) ->
              ?size:int -> Random.State.t -> 'a t
            val gen1 :
              (?size:int -> Random.State.t -> 'a) ->
              ?size:int -> Random.State.t -> 'a t
          end
      module rec MonoMap :
        functor (K : Types.Mono.Comparable->
          functor (V : Types.Mono.Comparable->
            sig
              type t
              type key = K.t
              type elt = V.t
              type cursor
              type 'a result = 'a * MonoMap(K)(V).t
              type 'a key_ = key
              type 'a elt_ = elt
              type ('a, 'b) map = t
              type ('a, 'b, 'c) result_ = 'a result
              val empty : ('a, 'b) map
              val is_empty : ('a, 'b) map -> bool
              val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
              val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
              val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
              val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
              val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
              val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val min_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val max_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val cardinal : ('a, 'b) map -> int
              val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
              val fold :
                ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
              val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
              val mapi :
                ('a key_ -> 'b elt_ -> 'c elt_) ->
                ('a, 'b) map -> ('a, 'c) map
              val union :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val inter :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val diff :
                ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val well_formed : ('a, 'b) map -> bool
              val of_result : ('a, 'b, 'c) result_ -> 'a
              type ('a, 'b) cursor_ = cursor
              val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
              val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
              val at_top : ('a, 'b) cursor_ -> bool
              val at_left : ('a, 'b) cursor_ -> bool
              val at_right : ('a, 'b) cursor_ -> bool
              val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val went_left : ('a, 'b) cursor_ -> bool
              val went_right : ('a, 'b) cursor_ -> bool
              val has_value : ('a, 'b) cursor_ -> bool
              val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
              val compare_keys : t -> t -> int
              val compare : t -> t -> int
              val to_string : t -> string
              val gen2 :
                (?size:int -> Random.State.t -> key) ->
                (?size:int -> Random.State.t -> elt) ->
                ?size:int -> Random.State.t -> t
            end
      module rec GenMap :
        functor (K : Types.Mono.ArbitraryComparable->
          functor (V : Types.Mono.ArbitraryComparable->
            sig
              type t
              type key = K.t
              type elt = V.t
              type cursor
              type 'a result = 'a * GenMap(K)(V).t
              type 'a key_ = key
              type 'a elt_ = elt
              type ('a, 'b) map = t
              type ('a, 'b, 'c) result_ = 'a result
              val empty : ('a, 'b) map
              val is_empty : ('a, 'b) map -> bool
              val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
              val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
              val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
              val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
              val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
              val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
              val min_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val max_keyval :
                ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
              val cardinal : ('a, 'b) map -> int
              val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
              val fold :
                ('-> 'b key_ -> 'c elt_ -> 'a) -> '-> ('b, 'c) map -> 'a
              val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
              val mapi :
                ('a key_ -> 'b elt_ -> 'c elt_) ->
                ('a, 'b) map -> ('a, 'c) map
              val union :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val inter :
                ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val diff :
                ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
                ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
              val well_formed : ('a, 'b) map -> bool
              val of_result : ('a, 'b, 'c) result_ -> 'a
              type ('a, 'b) cursor_ = cursor
              val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
              val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
              val at_top : ('a, 'b) cursor_ -> bool
              val at_left : ('a, 'b) cursor_ -> bool
              val at_right : ('a, 'b) cursor_ -> bool
              val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
              val went_left : ('a, 'b) cursor_ -> bool
              val went_right : ('a, 'b) cursor_ -> bool
              val has_value : ('a, 'b) cursor_ -> bool
              val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
              val compare_keys : t -> t -> int
              val compare : t -> t -> int
              val to_string : t -> string
              val gen2 :
                (?size:int -> Random.State.t -> key) ->
                (?size:int -> Random.State.t -> elt) ->
                ?size:int -> Random.State.t -> t
              val gen : ?size:int -> Random.State.t -> t
            end
    end
  module Dug :
    sig
      module Id : Types.Integral
      type ('a, 'b, 'c) kind =
          Generator of 'a
        | Mutator of 'b
        | Observer of 'c
      type ('a, 'b, 'c) edge = {
        target : Id.t;
        op : ('a, 'b, 'c) Reins.Dug.kind;
        pos : int;
      }
      type ('a, 'b, 'c) t = {
        mutable current_id : Id.t;
        nodes : (Id.t, ('a, 'b, 'c) Reins.Dug.kind) Hashtbl.t;
        edges : (Id.t, ('a, 'b, 'c) Reins.Dug.edge) Hashtbl.t;
      }
      val create : unit -> ('a, 'b, 'c) Reins.Dug.t
      val clear : ('a, 'b, 'c) Reins.Dug.t -> unit
      val size : ('a, 'b, 'c) Reins.Dug.t -> Id.t
      val fresh_id : ('a, 'b, 'c) Reins.Dug.t -> Id.t
      val is_mutator : ('a, 'b, 'c) Reins.Dug.kind -> bool
      val is_generator : ('a, 'b, 'c) Reins.Dug.kind -> bool
      val is_observer : ('a, 'b, 'c) Reins.Dug.kind -> bool
    end
  module DugADT :
    sig
      module type S =
        sig
          type ('a, 'b) generator
          type ('a, 'b) mutator
          type ('a, 'b) observer
          type ('a, 'b) op
          val op_to_string : ('a, 'b) Reins.DugADT.S.op -> string
          val coerce_gen :
            ('a, 'b) Reins.DugADT.S.generator -> ('a, 'b) Reins.DugADT.S.op
          val coerce_mut :
            ('a, 'b) Reins.DugADT.S.mutator -> ('a, 'b) Reins.DugADT.S.op
          val coerce_obs :
            ('a, 'b) Reins.DugADT.S.observer -> ('a, 'b) Reins.DugADT.S.op
          val classify :
            ('a, 'b) Reins.DugADT.S.op ->
            (('a, 'b) Reins.DugADT.S.generator,
             ('a, 'b) Reins.DugADT.S.mutator,
             ('a, 'b) Reins.DugADT.S.observer)
            Reins.Dug.kind
          val strip :
            ('a, 'b) Reins.DugADT.S.op -> (unit, unit) Reins.DugADT.S.op
          val op_dependencies :
            ('a, Dug.Id.t) Reins.DugADT.S.op -> Dug.Id.t list
          val create_op :
            (unit, unit) Reins.DugADT.S.op ->
            Dug.Id.t ->
            (unit -> 'a) ->
            (int -> Dug.Id.t) -> ('a, Dug.Id.t) Reins.DugADT.S.op
        end
    end
  module DugExtractor :
    sig
      type 'a wrap = private { data : 'a; id : Dug.Id.t; }
      val mutate :
        ('a, 'b, 'c) Reins.Dug.t ->
        (Dug.Id.t -> 'b) ->
        ('-> 'd) ->
        'Reins.DugExtractor.wrap -> 'Reins.DugExtractor.wrap
      val mutate2 :
        ('a, 'b, 'c) Reins.Dug.t ->
        (Dug.Id.t -> 'b) ->
        ('-> '-> 'd) ->
        'Reins.DugExtractor.wrap ->
        'Reins.DugExtractor.wrap -> 'Reins.DugExtractor.wrap
      val observe :
        ('a, 'b, 'c) Reins.Dug.t ->
        '-> ('-> 'e) -> 'Reins.DugExtractor.wrap -> 'e
      val observe2 :
        ('a, 'b, 'c) Reins.Dug.t ->
        '->
        ('-> '-> 'e) ->
        'Reins.DugExtractor.wrap -> 'Reins.DugExtractor.wrap -> 'e
      val generate :
        ('a, 'b, 'c) Reins.Dug.t ->
        (Dug.Id.t -> 'a) -> '-> 'Reins.DugExtractor.wrap
    end
  module DugProfile :
    sig
      module Make :
        functor (DS : DugADT.S->
          sig
            type t = private {
              gen_cdf : ((unit, unit) DS.generator * float) list;
              mut_cdf : ((unit, unit) DS.mutator * float) list;
              obs_cdf : ((unit, unit) DS.observer * float) list;
              gen_ratio : float;
              obs_mut_ratio : float;
              mortality : float;
              pmf : float;
              pof : float;
            }
            val random_op : ('a * float) list -> 'a
            val to_string : Reins.DugProfile.Make.t -> string
            val profile :
              (('a, 'b) DS.generator, ('a, 'b) DS.mutator,
               ('a, 'b) DS.observer)
              Reins.Dug.t -> Reins.DugProfile.Make.t
          end
    end
  module DugGenerator :
    sig
      module Make :
        functor (DS : DugADT.S->
          functor (A : Types.Mono.ArbitraryComparable->
            sig
              val generate :
                DugProfile.Make(DS).t ->
                int ->
                ((A.t, Dug.Id.t) DS.generator, (A.t, Dug.Id.t) DS.mutator,
                 (A.t, Dug.Id.t) DS.observer)
                Reins.Dug.t
            end
    end
  module Oracle :
    sig
      module type RestrictedSet =
        sig
          type t
          type elt
          type cursor
          type 'a result = 'a
          type 'a elt_ = elt
          type 'a set = t
          type ('a, 'b) result_ = 'a result
          val empty : 'a set
          val is_empty : 'a set -> bool
          val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
          val add : 'a elt_ -> 'a set -> 'a set
          val singleton : 'a elt_ -> 'a set
          val remove : 'a elt_ -> 'a set -> 'a set
          val min_elt : 'a set -> ('a elt_, 'a) result_
          val max_elt : 'a set -> ('a elt_, 'a) result_
          val choose : 'a set -> ('a elt_, 'a) result_
          val cardinal : 'a set -> int
          val compare : 'a set -> 'a set -> int
          val equal : 'a set -> 'a set -> bool
          val iter : ('a elt_ -> unit) -> 'a set -> unit
          val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
          val union : 'a set -> 'a set -> 'a set
          val inter : 'a set -> 'a set -> 'a set
          val diff : 'a set -> 'a set -> 'a set
          val gen1 :
            (?size:int -> Random.State.t -> 'a elt_) ->
            ?size:int -> Random.State.t -> 'a set
          val well_formed : 'a set -> bool
          val of_result : ('a, 'b) result_ -> 'a
          type 'a cursor_ = cursor
          val to_cursor : 'a set -> 'a cursor_
          val from_cursor : 'a cursor_ -> 'a set
          val at_top : 'a cursor_ -> bool
          val at_left : 'a cursor_ -> bool
          val at_right : 'a cursor_ -> bool
          val move_up : 'a cursor_ -> 'a cursor_
          val move_down_left : 'a cursor_ -> 'a cursor_
          val move_down_right : 'a cursor_ -> 'a cursor_
          val went_left : 'a cursor_ -> bool
          val went_right : 'a cursor_ -> bool
          val has_value : 'a cursor_ -> bool
          val get_value : 'a cursor_ -> 'a elt_
          val to_string : 'a set -> string
          val gen : ?size:int -> Random.State.t -> t
        end
      module type ProfiledSet =
        sig
          type t
          type elt
          type cursor
          type 'a result = 'a
          type 'a elt_ = elt
          type 'a set = t
          type ('a, 'b) result_ = 'a result
          val empty : 'a set
          val is_empty : 'a set -> bool
          val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
          val add : 'a elt_ -> 'a set -> 'a set
          val singleton : 'a elt_ -> 'a set
          val remove : 'a elt_ -> 'a set -> 'a set
          val min_elt : 'a set -> ('a elt_, 'a) result_
          val max_elt : 'a set -> ('a elt_, 'a) result_
          val choose : 'a set -> ('a elt_, 'a) result_
          val cardinal : 'a set -> int
          val compare : 'a set -> 'a set -> int
          val equal : 'a set -> 'a set -> bool
          val iter : ('a elt_ -> unit) -> 'a set -> unit
          val fold : ('-> 'b elt_ -> 'a) -> '-> 'b set -> 'a
          val union : 'a set -> 'a set -> 'a set
          val inter : 'a set -> 'a set -> 'a set
          val diff : 'a set -> 'a set -> 'a set
          val gen1 :
            (?size:int -> Random.State.t ->