sig
  module Poly :
    sig
      module type Equatable =
        sig
          type 'a t
          val equal :
            'a Reins.Types.Poly.Equatable.t ->
            'a Reins.Types.Poly.Equatable.t -> bool
        end
      module type Comparable =
        sig
          type 'a t
          val compare :
            ('a -> 'a -> int) ->
            'a Reins.Types.Poly.Comparable.t ->
            'a Reins.Types.Poly.Comparable.t -> int
          val to_string :
            ('a -> string) -> 'a 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 -> 'a Reins.Types.Poly.Arbitrary.t
          val to_string :
            ('a -> string) -> 'a 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 : ('a -> string) -> 'a t -> string
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        end
      module ComposeComparable :
        functor (A : Comparable) ->
          functor (B : Comparable) ->
            sig
              type 'a t = 'a B.t A.t
              val compare :
                ('a -> 'a -> int) ->
                'a Reins.Types.Poly.ComposeComparable.t ->
                'a Reins.Types.Poly.ComposeComparable.t -> int
              val to_string :
                ('a -> string) ->
                'a Reins.Types.Poly.ComposeComparable.t -> string
            end
      module ComposeGen :
        functor (A : Arbitrary) ->
          functor (B : Arbitrary) ->
            sig
              type 'a t = 'a B.t A.t
              val gen :
                (?size:int -> Random.State.t -> 'a) ->
                ?size:int ->
                Random.State.t -> 'a Reins.Types.Poly.ComposeGen.t
              val to_string :
                ('a -> string) -> 'a Reins.Types.Poly.ComposeGen.t -> string
            end
      module ComposeGenComparable :
        functor (A : ArbitraryComparable) ->
          functor (B : ArbitraryComparable) ->
            sig
              type 'a t = 'a B.t A.t
              val gen :
                (?size:int -> Random.State.t -> 'a) ->
                ?size:int ->
                Random.State.t -> 'a Reins.Types.Poly.ComposeGenComparable.t
              val to_string :
                ('a -> string) ->
                'a Reins.Types.Poly.ComposeGenComparable.t -> string
              val compare :
                ('a -> 'a -> int) ->
                'a Reins.Types.Poly.ComposeGenComparable.t ->
                'a Reins.Types.Poly.ComposeGenComparable.t -> int
            end
      module Close :
        sig
          type 'a t = 'a
          val to_string : ('a -> 'b) -> 'a -> 'b
          val compare : ('a -> 'b -> 'c) -> 'a -> 'b -> '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 -> 'a
      val to_int : 'a -> '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 -> '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 : 'a -> 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 : 'a -> int
      val gen : ?size:'a -> 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 : 'a -> 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 : 'a -> int
      val gen : ?size:'a -> 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 : 'a -> int
      val gen : ?size:'a -> 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 : 'a -> int
      val gen : ?size:'a -> 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 : 'a -> int
      val gen : ?size:'a -> 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 : 'a -> int -> Reins.Types.Big_int.big_int
      val to_int : 'a -> 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 : 'a -> 'a -> bool
      val hash : 'a -> int
      val gen : ?size:'a -> 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 : 'a -> 'a -> bool
      val hash : 'a -> int
      val gen : ?size:'a -> 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 : 'a -> int
      val gen : ?size:int -> Random.State.t -> string
      val to_string : 'a -> 'a
    end
  module Option :
    sig
      type 'a t = 'a option
      val compare : ('a -> 'b -> 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 : ('a -> string) -> 'a option -> string
    end
end