sig
  module Predef :
    sig
      type _int = int
      type _char = char
      type _string = string
      type _float = float
      type _bool = bool
      type _unit = unit
      type _exn = exn
      type 'a _array = 'a array
      type 'a _list = 'a list
      type 'a _option = 'a option = None | Some of 'a
      type _nativeint = nativeint
      type _int32 = int32
      type _int64 = int64
      type 'a _lazy_t = 'a lazy_t
      type _bytes = bytes
    end
  type int = Ppx_deriving_runtime.Predef._int
  type char = Ppx_deriving_runtime.Predef._char
  type string = Ppx_deriving_runtime.Predef._string
  type float = Ppx_deriving_runtime.Predef._float
  type bool = Ppx_deriving_runtime.Predef._bool
  type unit = Ppx_deriving_runtime.Predef._unit
  type exn = Ppx_deriving_runtime.Predef._exn
  type 'a array = 'Ppx_deriving_runtime.Predef._array
  type 'a list = 'Ppx_deriving_runtime.Predef._list
  type 'a option = 'Ppx_deriving_runtime.Predef._option = None | Some of 'a
  type nativeint = Ppx_deriving_runtime.Predef._nativeint
  type int32 = Ppx_deriving_runtime.Predef._int32
  type int64 = Ppx_deriving_runtime.Predef._int64
  type 'a lazy_t = 'Ppx_deriving_runtime.Predef._lazy_t
  type bytes = Ppx_deriving_runtime.Predef._bytes
  module Pervasives :
    sig
      external raise : exn -> 'a = "%raise"
      external raise_notrace : exn -> 'a = "%raise_notrace"
      val invalid_arg : string -> 'a
      val failwith : string -> 'a
      exception Exit
      external ( = ) : '-> '-> bool = "%equal"
      external ( <> ) : '-> '-> bool = "%notequal"
      external ( < ) : '-> '-> bool = "%lessthan"
      external ( > ) : '-> '-> bool = "%greaterthan"
      external ( <= ) : '-> '-> bool = "%lessequal"
      external ( >= ) : '-> '-> bool = "%greaterequal"
      external compare : '-> '-> int = "%compare"
      val min : '-> '-> 'a
      val max : '-> '-> 'a
      external ( == ) : '-> '-> bool = "%eq"
      external ( != ) : '-> '-> bool = "%noteq"
      external not : bool -> bool = "%boolnot"
      external ( && ) : bool -> bool -> bool = "%sequand"
      external ( & ) : bool -> bool -> bool = "%sequand"
      external ( || ) : bool -> bool -> bool = "%sequor"
      external ( or ) : bool -> bool -> bool = "%sequor"
      external __LOC__ : string = "%loc_LOC"
      external __FILE__ : string = "%loc_FILE"
      external __LINE__ : int = "%loc_LINE"
      external __MODULE__ : string = "%loc_MODULE"
      external __POS__ : string * int * int * int = "%loc_POS"
      external __LOC_OF__ : '-> string * 'a = "%loc_LOC"
      external __LINE_OF__ : '-> int * 'a = "%loc_LINE"
      external __POS_OF__ : '-> (string * int * int * int) * 'a
        = "%loc_POS"
      external ( |> ) : '-> ('-> 'b) -> 'b = "%revapply"
      external ( @@ ) : ('-> 'b) -> '-> 'b = "%apply"
      external ( ~- ) : int -> int = "%negint"
      external ( ~+ ) : int -> int = "%identity"
      external succ : int -> int = "%succint"
      external pred : int -> int = "%predint"
      external ( + ) : int -> int -> int = "%addint"
      external ( - ) : int -> int -> int = "%subint"
      external ( * ) : int -> int -> int = "%mulint"
      external ( / ) : int -> int -> int = "%divint"
      external ( mod ) : int -> int -> int = "%modint"
      val abs : int -> int
      val max_int : int
      val min_int : int
      external ( land ) : int -> int -> int = "%andint"
      external ( lor ) : int -> int -> int = "%orint"
      external ( lxor ) : int -> int -> int = "%xorint"
      val lnot : int -> int
      external ( lsl ) : int -> int -> int = "%lslint"
      external ( lsr ) : int -> int -> int = "%lsrint"
      external ( asr ) : int -> int -> int = "%asrint"
      external ( ~-. ) : float -> float = "%negfloat"
      external ( ~+. ) : float -> float = "%identity"
      external ( +. ) : float -> float -> float = "%addfloat"
      external ( -. ) : float -> float -> float = "%subfloat"
      external ( *. ) : float -> float -> float = "%mulfloat"
      external ( /. ) : float -> float -> float = "%divfloat"
      external ( ** ) : float -> float -> float = "caml_power_float" "pow"
        [@@unboxed] [@@noalloc]
      external sqrt : float -> float = "caml_sqrt_float" "sqrt" [@@unboxed]
        [@@noalloc]
      external exp : float -> float = "caml_exp_float" "exp" [@@unboxed]
        [@@noalloc]
      external log : float -> float = "caml_log_float" "log" [@@unboxed]
        [@@noalloc]
      external log10 : float -> float = "caml_log10_float" "log10"
        [@@unboxed] [@@noalloc]
      external expm1 : float -> float = "caml_expm1_float" "caml_expm1"
        [@@unboxed] [@@noalloc]
      external log1p : float -> float = "caml_log1p_float" "caml_log1p"
        [@@unboxed] [@@noalloc]
      external cos : float -> float = "caml_cos_float" "cos" [@@unboxed]
        [@@noalloc]
      external sin : float -> float = "caml_sin_float" "sin" [@@unboxed]
        [@@noalloc]
      external tan : float -> float = "caml_tan_float" "tan" [@@unboxed]
        [@@noalloc]
      external acos : float -> float = "caml_acos_float" "acos" [@@unboxed]
        [@@noalloc]
      external asin : float -> float = "caml_asin_float" "asin" [@@unboxed]
        [@@noalloc]
      external atan : float -> float = "caml_atan_float" "atan" [@@unboxed]
        [@@noalloc]
      external atan2 : float -> float -> float = "caml_atan2_float" "atan2"
        [@@unboxed] [@@noalloc]
      external hypot : float -> float -> float = "caml_hypot_float"
        "caml_hypot" [@@unboxed] [@@noalloc]
      external cosh : float -> float = "caml_cosh_float" "cosh" [@@unboxed]
        [@@noalloc]
      external sinh : float -> float = "caml_sinh_float" "sinh" [@@unboxed]
        [@@noalloc]
      external tanh : float -> float = "caml_tanh_float" "tanh" [@@unboxed]
        [@@noalloc]
      external ceil : float -> float = "caml_ceil_float" "ceil" [@@unboxed]
        [@@noalloc]
      external floor : float -> float = "caml_floor_float" "floor"
        [@@unboxed] [@@noalloc]
      external abs_float : float -> float = "%absfloat"
      external copysign : float -> float -> float = "caml_copysign_float"
        "caml_copysign" [@@unboxed] [@@noalloc]
      external mod_float : float -> float -> float = "caml_fmod_float" "fmod"
        [@@unboxed] [@@noalloc]
      external frexp : float -> float * int = "caml_frexp_float"
      external ldexp :
        (float [@unboxed]) -> (int [@untagged]) -> (float [@unboxed])
        = "caml_ldexp_float" "caml_ldexp_float_unboxed" [@@noalloc]
      external modf : float -> float * float = "caml_modf_float"
      external float : int -> float = "%floatofint"
      external float_of_int : int -> float = "%floatofint"
      external truncate : float -> int = "%intoffloat"
      external int_of_float : float -> int = "%intoffloat"
      val infinity : float
      val neg_infinity : float
      val nan : float
      val max_float : float
      val min_float : float
      val epsilon_float : float
      type fpclass =
        fpclass =
          FP_normal
        | FP_subnormal
        | FP_zero
        | FP_infinite
        | FP_nan
      external classify_float : (float [@unboxed]) -> fpclass
        = "caml_classify_float" "caml_classify_float_unboxed" [@@noalloc]
      val ( ^ ) : string -> string -> string
      external int_of_char : char -> int = "%identity"
      val char_of_int : int -> char
      external ignore : '-> unit = "%ignore"
      val string_of_bool : bool -> string
      val bool_of_string : string -> bool
      val bool_of_string_opt : string -> bool option
      val string_of_int : int -> string
      external int_of_string : string -> int = "caml_int_of_string"
      val int_of_string_opt : string -> int option
      val string_of_float : float -> string
      external float_of_string : string -> float = "caml_float_of_string"
      val float_of_string_opt : string -> float option
      external fst : 'a * '-> 'a = "%field0"
      external snd : 'a * '-> 'b = "%field1"
      val ( @ ) : 'a list -> 'a list -> 'a list
      type in_channel = in_channel
      type out_channel = out_channel
      val stdin : in_channel
      val stdout : out_channel
      val stderr : out_channel
      val print_char : char -> unit
      val print_string : string -> unit
      val print_bytes : bytes -> unit
      val print_int : int -> unit
      val print_float : float -> unit
      val print_endline : string -> unit
      val print_newline : unit -> unit
      val prerr_char : char -> unit
      val prerr_string : string -> unit
      val prerr_bytes : bytes -> unit
      val prerr_int : int -> unit
      val prerr_float : float -> unit
      val prerr_endline : string -> unit
      val prerr_newline : unit -> unit
      val read_line : unit -> string
      val read_int : unit -> int
      val read_int_opt : unit -> int option
      val read_float : unit -> float
      val read_float_opt : unit -> float option
      type open_flag =
        open_flag =
          Open_rdonly
        | Open_wronly
        | Open_append
        | Open_creat
        | Open_trunc
        | Open_excl
        | Open_binary
        | Open_text
        | Open_nonblock
      val open_out : string -> out_channel
      val open_out_bin : string -> out_channel
      val open_out_gen : open_flag list -> int -> string -> out_channel
      val flush : out_channel -> unit
      val flush_all : unit -> unit
      val output_char : out_channel -> char -> unit
      val output_string : out_channel -> string -> unit
      val output_bytes : out_channel -> bytes -> unit
      val output : out_channel -> bytes -> int -> int -> unit
      val output_substring : out_channel -> string -> int -> int -> unit
      val output_byte : out_channel -> int -> unit
      val output_binary_int : out_channel -> int -> unit
      val output_value : out_channel -> '-> unit
      val seek_out : out_channel -> int -> unit
      val pos_out : out_channel -> int
      val out_channel_length : out_channel -> int
      val close_out : out_channel -> unit
      val close_out_noerr : out_channel -> unit
      val set_binary_mode_out : out_channel -> bool -> unit
      val open_in : string -> in_channel
      val open_in_bin : string -> in_channel
      val open_in_gen : open_flag list -> int -> string -> in_channel
      val input_char : in_channel -> char
      val input_line : in_channel -> string
      val input : in_channel -> bytes -> int -> int -> int
      val really_input : in_channel -> bytes -> int -> int -> unit
      val really_input_string : in_channel -> int -> string
      val input_byte : in_channel -> int
      val input_binary_int : in_channel -> int
      val input_value : in_channel -> 'a
      val seek_in : in_channel -> int -> unit
      val pos_in : in_channel -> int
      val in_channel_length : in_channel -> int
      val close_in : in_channel -> unit
      val close_in_noerr : in_channel -> unit
      val set_binary_mode_in : in_channel -> bool -> unit
      module LargeFile :
        sig
          val seek_out : out_channel -> int64 -> unit
          val pos_out : out_channel -> int64
          val out_channel_length : out_channel -> int64
          val seek_in : in_channel -> int64 -> unit
          val pos_in : in_channel -> int64
          val in_channel_length : in_channel -> int64
        end
      type 'a ref = 'a ref = { mutable contents : 'a; }
      external ref : '-> 'a ref = "%makemutable"
      external ( ! ) : 'a ref -> 'a = "%field0"
      external ( := ) : 'a ref -> '-> unit = "%setfield0"
      external incr : int ref -> unit = "%incr"
      external decr : int ref -> unit = "%decr"
      type ('a, 'b) result = Ok of '| Error of 'b
      type ('a, 'b, 'c, 'd, 'e, 'f) format6 =
          ('a, 'b, 'c, 'd, 'e, 'f) format6
      type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) format4
      type ('a, 'b, 'c) format = ('a, 'b, 'c) format
      val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
      external format_of_string :
        ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
        = "%identity"
      val ( ^^ ) :
        ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
        ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
      val exit : int -> 'a
      val at_exit : (unit -> unit) -> unit
      val valid_float_lexem : string -> string
      val unsafe_really_input : in_channel -> bytes -> int -> int -> unit
      val do_at_exit : unit -> unit
    end
  external raise : exn -> 'a = "%raise"
  external raise_notrace : exn -> 'a = "%raise_notrace"
  val invalid_arg : string -> 'a
  val failwith : string -> 'a
  exception Exit
  external ( = ) : '-> '-> bool = "%equal"
  external ( <> ) : '-> '-> bool = "%notequal"
  external ( < ) : '-> '-> bool = "%lessthan"
  external ( > ) : '-> '-> bool = "%greaterthan"
  external ( <= ) : '-> '-> bool = "%lessequal"
  external ( >= ) : '-> '-> bool = "%greaterequal"
  external compare : '-> '-> int = "%compare"
  val min : '-> '-> 'a
  val max : '-> '-> 'a
  external ( == ) : '-> '-> bool = "%eq"
  external ( != ) : '-> '-> bool = "%noteq"
  external not : bool -> bool = "%boolnot"
  external ( && ) : bool -> bool -> bool = "%sequand"
  external ( & ) : bool -> bool -> bool = "%sequand"
  external ( || ) : bool -> bool -> bool = "%sequor"
  external ( or ) : bool -> bool -> bool = "%sequor"
  external __LOC__ : string = "%loc_LOC"
  external __FILE__ : string = "%loc_FILE"
  external __LINE__ : int = "%loc_LINE"
  external __MODULE__ : string = "%loc_MODULE"
  external __POS__ : string * int * int * int = "%loc_POS"
  external __LOC_OF__ : '-> string * 'a = "%loc_LOC"
  external __LINE_OF__ : '-> int * 'a = "%loc_LINE"
  external __POS_OF__ : '-> (string * int * int * int) * 'a = "%loc_POS"
  external ( |> ) : '-> ('-> 'b) -> 'b = "%revapply"
  external ( @@ ) : ('-> 'b) -> '-> 'b = "%apply"
  external ( ~- ) : int -> int = "%negint"
  external ( ~+ ) : int -> int = "%identity"
  external succ : int -> int = "%succint"
  external pred : int -> int = "%predint"
  external ( + ) : int -> int -> int = "%addint"
  external ( - ) : int -> int -> int = "%subint"
  external ( * ) : int -> int -> int = "%mulint"
  external ( / ) : int -> int -> int = "%divint"
  external ( mod ) : int -> int -> int = "%modint"
  val abs : int -> int
  val max_int : int
  val min_int : int
  external ( land ) : int -> int -> int = "%andint"
  external ( lor ) : int -> int -> int = "%orint"
  external ( lxor ) : int -> int -> int = "%xorint"
  val lnot : int -> int
  external ( lsl ) : int -> int -> int = "%lslint"
  external ( lsr ) : int -> int -> int = "%lsrint"
  external ( asr ) : int -> int -> int = "%asrint"
  external ( ~-. ) : float -> float = "%negfloat"
  external ( ~+. ) : float -> float = "%identity"
  external ( +. ) : float -> float -> float = "%addfloat"
  external ( -. ) : float -> float -> float = "%subfloat"
  external ( *. ) : float -> float -> float = "%mulfloat"
  external ( /. ) : float -> float -> float = "%divfloat"
  external ( ** ) : float -> float -> float = "caml_power_float" "pow"
    [@@unboxed] [@@noalloc]
  external sqrt : float -> float = "caml_sqrt_float" "sqrt" [@@unboxed]
    [@@noalloc]
  external exp : float -> float = "caml_exp_float" "exp" [@@unboxed]
    [@@noalloc]
  external log : float -> float = "caml_log_float" "log" [@@unboxed]
    [@@noalloc]
  external log10 : float -> float = "caml_log10_float" "log10" [@@unboxed]
    [@@noalloc]
  external expm1 : float -> float = "caml_expm1_float" "caml_expm1"
    [@@unboxed] [@@noalloc]
  external log1p : float -> float = "caml_log1p_float" "caml_log1p"
    [@@unboxed] [@@noalloc]
  external cos : float -> float = "caml_cos_float" "cos" [@@unboxed]
    [@@noalloc]
  external sin : float -> float = "caml_sin_float" "sin" [@@unboxed]
    [@@noalloc]
  external tan : float -> float = "caml_tan_float" "tan" [@@unboxed]
    [@@noalloc]
  external acos : float -> float = "caml_acos_float" "acos" [@@unboxed]
    [@@noalloc]
  external asin : float -> float = "caml_asin_float" "asin" [@@unboxed]
    [@@noalloc]
  external atan : float -> float = "caml_atan_float" "atan" [@@unboxed]
    [@@noalloc]
  external atan2 : float -> float -> float = "caml_atan2_float" "atan2"
    [@@unboxed] [@@noalloc]
  external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot"
    [@@unboxed] [@@noalloc]
  external cosh : float -> float = "caml_cosh_float" "cosh" [@@unboxed]
    [@@noalloc]
  external sinh : float -> float = "caml_sinh_float" "sinh" [@@unboxed]
    [@@noalloc]
  external tanh : float -> float = "caml_tanh_float" "tanh" [@@unboxed]
    [@@noalloc]
  external ceil : float -> float = "caml_ceil_float" "ceil" [@@unboxed]
    [@@noalloc]
  external floor : float -> float = "caml_floor_float" "floor" [@@unboxed]
    [@@noalloc]
  external abs_float : float -> float = "%absfloat"
  external copysign : float -> float -> float = "caml_copysign_float"
    "caml_copysign" [@@unboxed] [@@noalloc]
  external mod_float : float -> float -> float = "caml_fmod_float" "fmod"
    [@@unboxed] [@@noalloc]
  external frexp : float -> float * int = "caml_frexp_float"
  external ldexp :
    (float [@unboxed]) -> (int [@untagged]) -> (float [@unboxed])
    = "caml_ldexp_float" "caml_ldexp_float_unboxed" [@@noalloc]
  external modf : float -> float * float = "caml_modf_float"
  external float : int -> float = "%floatofint"
  external float_of_int : int -> float = "%floatofint"
  external truncate : float -> int = "%intoffloat"
  external int_of_float : float -> int = "%intoffloat"
  val infinity : float
  val neg_infinity : float
  val nan : float
  val max_float : float
  val min_float : float
  val epsilon_float : float
  type fpclass =
    Pervasives.fpclass =
      FP_normal
    | FP_subnormal
    | FP_zero
    | FP_infinite
    | FP_nan
  external classify_float : (float [@unboxed]) -> fpclass
    = "caml_classify_float" "caml_classify_float_unboxed" [@@noalloc]
  val ( ^ ) : string -> string -> string
  external int_of_char : char -> int = "%identity"
  val char_of_int : int -> char
  external ignore : '-> unit = "%ignore"
  val string_of_bool : bool -> string
  val bool_of_string : string -> bool
  val bool_of_string_opt : string -> bool option
  val string_of_int : int -> string
  external int_of_string : string -> int = "caml_int_of_string"
  val int_of_string_opt : string -> int option
  val string_of_float : float -> string
  external float_of_string : string -> float = "caml_float_of_string"
  val float_of_string_opt : string -> float option
  external fst : 'a * '-> 'a = "%field0"
  external snd : 'a * '-> 'b = "%field1"
  val ( @ ) : 'a list -> 'a list -> 'a list
  type in_channel = Pervasives.in_channel
  type out_channel = Pervasives.out_channel
  val stdin : in_channel
  val stdout : out_channel
  val stderr : out_channel
  val print_char : char -> unit
  val print_string : string -> unit
  val print_bytes : bytes -> unit
  val print_int : int -> unit
  val print_float : float -> unit
  val print_endline : string -> unit
  val print_newline : unit -> unit
  val prerr_char : char -> unit
  val prerr_string : string -> unit
  val prerr_bytes : bytes -> unit
  val prerr_int : int -> unit
  val prerr_float : float -> unit
  val prerr_endline : string -> unit
  val prerr_newline : unit -> unit
  val read_line : unit -> string
  val read_int : unit -> int
  val read_int_opt : unit -> int option
  val read_float : unit -> float
  val read_float_opt : unit -> float option
  type open_flag =
    Pervasives.open_flag =
      Open_rdonly
    | Open_wronly
    | Open_append
    | Open_creat
    | Open_trunc
    | Open_excl
    | Open_binary
    | Open_text
    | Open_nonblock
  val open_out : string -> out_channel
  val open_out_bin : string -> out_channel
  val open_out_gen : open_flag list -> int -> string -> out_channel
  val flush : out_channel -> unit
  val flush_all : unit -> unit
  val output_char : out_channel -> char -> unit
  val output_string : out_channel -> string -> unit
  val output_bytes : out_channel -> bytes -> unit
  val output : out_channel -> bytes -> int -> int -> unit
  val output_substring : out_channel -> string -> int -> int -> unit
  val output_byte : out_channel -> int -> unit
  val output_binary_int : out_channel -> int -> unit
  val output_value : out_channel -> '-> unit
  val seek_out : out_channel -> int -> unit
  val pos_out : out_channel -> int
  val out_channel_length : out_channel -> int
  val close_out : out_channel -> unit
  val close_out_noerr : out_channel -> unit
  val set_binary_mode_out : out_channel -> bool -> unit
  val open_in : string -> in_channel
  val open_in_bin : string -> in_channel
  val open_in_gen : open_flag list -> int -> string -> in_channel
  val input_char : in_channel -> char
  val input_line : in_channel -> string
  val input : in_channel -> bytes -> int -> int -> int
  val really_input : in_channel -> bytes -> int -> int -> unit
  val really_input_string : in_channel -> int -> string
  val input_byte : in_channel -> int
  val input_binary_int : in_channel -> int
  val input_value : in_channel -> 'a
  val seek_in : in_channel -> int -> unit
  val pos_in : in_channel -> int
  val in_channel_length : in_channel -> int
  val close_in : in_channel -> unit
  val close_in_noerr : in_channel -> unit
  val set_binary_mode_in : in_channel -> bool -> unit
  module LargeFile :
    sig
      val seek_out : out_channel -> int64 -> unit
      val pos_out : out_channel -> int64
      val out_channel_length : out_channel -> int64
      val seek_in : in_channel -> int64 -> unit
      val pos_in : in_channel -> int64
      val in_channel_length : in_channel -> int64
    end
  type 'a ref = 'Pervasives.ref = { mutable contents : 'a; }
  external ref : '-> 'a ref = "%makemutable"
  external ( ! ) : 'a ref -> 'a = "%field0"
  external ( := ) : 'a ref -> '-> unit = "%setfield0"
  external incr : int ref -> unit = "%incr"
  external decr : int ref -> unit = "%decr"
  type ('a, 'b) result = Ok of '| Error of 'b
  type ('a, 'b, 'c, 'd, 'e, 'f) format6 =
      ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6
  type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) Pervasives.format4
  type ('a, 'b, 'c) format = ('a, 'b, 'c) Pervasives.format
  val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
  external format_of_string :
    ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
    = "%identity"
  val ( ^^ ) :
    ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
    ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
  val exit : int -> 'a
  val at_exit : (unit -> unit) -> unit
  val valid_float_lexem : string -> string
  val unsafe_really_input : in_channel -> bytes -> int -> int -> unit
  val do_at_exit : unit -> unit
  module Char :
    sig
      external code : char -> int = "%identity"
      val chr : int -> char
      val escaped : char -> string
      val lowercase : char -> char
      val uppercase : char -> char
      val lowercase_ascii : char -> char
      val uppercase_ascii : char -> char
      type t = char
      val compare : t -> t -> int
      val equal : t -> t -> bool
      external unsafe_chr : int -> char = "%identity"
    end
  module String :
    sig
      external length : string -> int = "%string_length"
      external get : string -> int -> char = "%string_safe_get"
      external set : bytes -> int -> char -> unit = "%string_safe_set"
      external create : int -> bytes = "caml_create_string"
      val make : int -> char -> string
      val init : int -> (int -> char) -> string
      val copy : string -> string
      val sub : string -> int -> int -> string
      val fill : bytes -> int -> int -> char -> unit
      val blit : string -> int -> bytes -> int -> int -> unit
      val concat : string -> string list -> string
      val iter : (char -> unit) -> string -> unit
      val iteri : (int -> char -> unit) -> string -> unit
      val map : (char -> char) -> string -> string
      val mapi : (int -> char -> char) -> string -> string
      val trim : string -> string
      val escaped : string -> string
      val index : string -> char -> int
      val index_opt : string -> char -> int option
      val rindex : string -> char -> int
      val rindex_opt : string -> char -> int option
      val index_from : string -> int -> char -> int
      val index_from_opt : string -> int -> char -> int option
      val rindex_from : string -> int -> char -> int
      val rindex_from_opt : string -> int -> char -> int option
      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
      val uppercase_ascii : string -> string
      val lowercase_ascii : string -> string
      val capitalize_ascii : string -> string
      val uncapitalize_ascii : string -> string
      type t = string
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val split_on_char : char -> string -> string list
      external unsafe_get : string -> int -> char = "%string_unsafe_get"
      external unsafe_set : bytes -> int -> char -> unit
        = "%string_unsafe_set"
      external unsafe_blit : string -> int -> bytes -> int -> int -> unit
        = "caml_blit_string" [@@noalloc]
      external unsafe_fill : bytes -> int -> int -> char -> unit
        = "caml_fill_string" [@@noalloc]
    end
  module Printexc :
    sig
      val to_string : exn -> string
      val print : ('-> 'b) -> '-> 'b
      val catch : ('-> 'b) -> '-> 'b
      val print_backtrace : out_channel -> unit
      val get_backtrace : unit -> string
      val record_backtrace : bool -> unit
      val backtrace_status : unit -> bool
      val register_printer : (exn -> string option) -> unit
      val get_raw_backtrace : unit -> Printexc.raw_backtrace
      val print_raw_backtrace : out_channel -> Printexc.raw_backtrace -> unit
      val raw_backtrace_to_string : Printexc.raw_backtrace -> string
      external raise_with_backtrace : exn -> Printexc.raw_backtrace -> 'a
        = "%raise_with_backtrace"
      val get_callstack : int -> Printexc.raw_backtrace
      val set_uncaught_exception_handler :
        (exn -> Printexc.raw_backtrace -> unit) -> unit
      val backtrace_slots :
        Printexc.raw_backtrace -> Printexc.backtrace_slot array option
      module Slot :
        sig
          type t = Printexc.backtrace_slot
          val is_raise : t -> bool
          val is_inline : t -> bool
          val location : t -> Printexc.location option
          val format : int -> t -> string option
        end
      type raw_backtrace_slot
      val raw_backtrace_length : Printexc.raw_backtrace -> int
      val get_raw_backtrace_slot :
        Printexc.raw_backtrace -> int -> raw_backtrace_slot
      val convert_raw_backtrace_slot :
        raw_backtrace_slot -> Printexc.backtrace_slot
      val get_raw_backtrace_next_slot :
        raw_backtrace_slot -> raw_backtrace_slot option
      val exn_slot_id : exn -> int
      val exn_slot_name : exn -> string
    end
  module Array :
    sig
      external length : 'a array -> int = "%array_length"
      external get : 'a array -> int -> 'a = "%array_safe_get"
      external set : 'a array -> int -> '-> unit = "%array_safe_set"
      external make : int -> '-> 'a array = "caml_make_vect"
      external create : int -> '-> 'a array = "caml_make_vect"
      external create_float : int -> float array = "caml_make_float_vect"
      val make_float : int -> float array
      val init : int -> (int -> 'a) -> 'a array
      val make_matrix : int -> int -> '-> 'a array array
      val create_matrix : int -> int -> '-> 'a array array
      val append : 'a array -> 'a array -> 'a array
      val concat : 'a array list -> 'a array
      val sub : 'a array -> int -> int -> 'a array
      val copy : 'a array -> 'a array
      val fill : 'a array -> int -> int -> '-> unit
      val blit : 'a array -> int -> 'a array -> int -> int -> unit
      val to_list : 'a array -> 'a list
      val of_list : 'a list -> 'a array
      val iter : ('-> unit) -> 'a array -> unit
      val iteri : (int -> '-> unit) -> 'a array -> unit
      val map : ('-> 'b) -> 'a array -> 'b array
      val mapi : (int -> '-> 'b) -> 'a array -> 'b array
      val fold_left : ('-> '-> 'a) -> '-> 'b array -> 'a
      val fold_right : ('-> '-> 'a) -> 'b array -> '-> 'a
      val iter2 : ('-> '-> unit) -> 'a array -> 'b array -> unit
      val map2 : ('-> '-> 'c) -> 'a array -> 'b array -> 'c array
      val for_all : ('-> bool) -> 'a array -> bool
      val exists : ('-> bool) -> 'a array -> bool
      val mem : '-> 'a array -> bool
      val memq : '-> 'a array -> bool
      val sort : ('-> '-> int) -> 'a array -> unit
      val stable_sort : ('-> '-> int) -> 'a array -> unit
      val fast_sort : ('-> '-> int) -> 'a array -> unit
      external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
      external unsafe_set : 'a array -> int -> '-> unit
        = "%array_unsafe_set"
    end
  module List :
    sig
      val length : 'a list -> int
      val compare_lengths : 'a list -> 'b list -> int
      val compare_length_with : 'a list -> int -> int
      val cons : '-> 'a list -> 'a list
      val hd : 'a list -> 'a
      val tl : 'a list -> 'a list
      val nth : 'a list -> int -> 'a
      val nth_opt : 'a list -> int -> 'a option
      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 iteri : (int -> '-> unit) -> 'a list -> unit
      val map : ('-> 'b) -> 'a list -> 'b list
      val mapi : (int -> '-> '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 find_opt : ('-> bool) -> 'a list -> 'a option
      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 assoc_opt : '-> ('a * 'b) list -> 'b option
      val assq : '-> ('a * 'b) list -> 'b
      val assq_opt : '-> ('a * 'b) list -> 'b option
      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 sort_uniq : ('-> '-> int) -> 'a list -> 'a list
      val merge : ('-> '-> int) -> 'a list -> 'a list -> 'a list
    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"
        "caml_nativeint_of_float_unboxed" [@@unboxed] [@@noalloc]
      external to_float : nativeint -> float = "caml_nativeint_to_float"
        "caml_nativeint_to_float_unboxed" [@@unboxed] [@@noalloc]
      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 of_string_opt : string -> nativeint option
      val to_string : nativeint -> string
      type t = nativeint
      val compare : t -> t -> int
      val equal : t -> t -> bool
      external format : string -> nativeint -> string
        = "caml_nativeint_format"
    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"
        "caml_int32_of_float_unboxed" [@@unboxed] [@@noalloc]
      external to_float : int32 -> float = "caml_int32_to_float"
        "caml_int32_to_float_unboxed" [@@unboxed] [@@noalloc]
      external of_string : string -> int32 = "caml_int32_of_string"
      val of_string_opt : string -> int32 option
      val to_string : int32 -> string
      external bits_of_float : float -> int32 = "caml_int32_bits_of_float"
        "caml_int32_bits_of_float_unboxed" [@@unboxed] [@@noalloc]
      external float_of_bits : int32 -> float = "caml_int32_float_of_bits"
        "caml_int32_float_of_bits_unboxed" [@@unboxed] [@@noalloc]
      type t = int32
      val compare : t -> t -> int
      val equal : t -> t -> bool
      external format : string -> int32 -> string = "caml_int32_format"
    end
  module Int64 :
    sig
      val zero : int64
      val one : int64
      val minus_one : int64
      external neg : int64 -> int64 = "%int64_neg"
      external add : int64 -> int64 -> int64 = "%int64_add"
      external sub : int64 -> int64 -> int64 = "%int64_sub"
      external mul : int64 -> int64 -> int64 = "%int64_mul"
      external div : int64 -> int64 -> int64 = "%int64_div"
      external rem : int64 -> int64 -> int64 = "%int64_mod"
      val succ : int64 -> int64
      val pred : int64 -> int64
      val abs : int64 -> int64
      val max_int : int64
      val min_int : int64
      external logand : int64 -> int64 -> int64 = "%int64_and"
      external logor : int64 -> int64 -> int64 = "%int64_or"
      external logxor : int64 -> int64 -> int64 = "%int64_xor"
      val lognot : int64 -> int64
      external shift_left : int64 -> int -> int64 = "%int64_lsl"
      external shift_right : int64 -> int -> int64 = "%int64_asr"
      external shift_right_logical : int64 -> int -> int64 = "%int64_lsr"
      external of_int : int -> int64 = "%int64_of_int"
      external to_int : int64 -> int = "%int64_to_int"
      external of_float : float -> int64 = "caml_int64_of_float"
        "caml_int64_of_float_unboxed" [@@unboxed] [@@noalloc]
      external to_float : int64 -> float = "caml_int64_to_float"
        "caml_int64_to_float_unboxed" [@@unboxed] [@@noalloc]
      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 of_string_opt : string -> int64 option
      val to_string : int64 -> string
      external bits_of_float : float -> int64 = "caml_int64_bits_of_float"
        "caml_int64_bits_of_float_unboxed" [@@unboxed] [@@noalloc]
      external float_of_bits : int64 -> float = "caml_int64_float_of_bits"
        "caml_int64_float_of_bits_unboxed" [@@unboxed] [@@noalloc]
      type t = int64
      val compare : t -> t -> int
      val equal : t -> t -> bool
      external format : string -> int64 -> string = "caml_int64_format"
    end
  module Lazy :
    sig
      type 'a t = 'a lazy_t
      exception Undefined
      external force : 'a t -> 'a = "%lazy_force"
      val force_val : 'a t -> 'a
      val from_fun : (unit -> 'a) -> 'a t
      val from_val : '-> 'a t
      val is_val : 'a t -> bool
      val lazy_from_fun : (unit -> 'a) -> 'a t
      val lazy_from_val : '-> 'a t
      val lazy_is_val : 'a t -> bool
    end
  module Bytes :
    sig
      external length : bytes -> int = "%bytes_length"
      external get : bytes -> int -> char = "%bytes_safe_get"
      external set : bytes -> int -> char -> unit = "%bytes_safe_set"
      external create : int -> bytes = "caml_create_bytes"
      val make : int -> char -> bytes
      val init : int -> (int -> char) -> bytes
      val empty : bytes
      val copy : bytes -> bytes
      val of_string : string -> bytes
      val to_string : bytes -> string
      val sub : bytes -> int -> int -> bytes
      val sub_string : bytes -> int -> int -> string
      val extend : bytes -> int -> int -> bytes
      val fill : bytes -> int -> int -> char -> unit
      val blit : bytes -> int -> bytes -> int -> int -> unit
      val blit_string : string -> int -> bytes -> int -> int -> unit
      val concat : bytes -> bytes list -> bytes
      val cat : bytes -> bytes -> bytes
      val iter : (char -> unit) -> bytes -> unit
      val iteri : (int -> char -> unit) -> bytes -> unit
      val map : (char -> char) -> bytes -> bytes
      val mapi : (int -> char -> char) -> bytes -> bytes
      val trim : bytes -> bytes
      val escaped : bytes -> bytes
      val index : bytes -> char -> int
      val index_opt : bytes -> char -> int option
      val rindex : bytes -> char -> int
      val rindex_opt : bytes -> char -> int option
      val index_from : bytes -> int -> char -> int
      val index_from_opt : bytes -> int -> char -> int option
      val rindex_from : bytes -> int -> char -> int
      val rindex_from_opt : bytes -> int -> char -> int option
      val contains : bytes -> char -> bool
      val contains_from : bytes -> int -> char -> bool
      val rcontains_from : bytes -> int -> char -> bool
      val uppercase : bytes -> bytes
      val lowercase : bytes -> bytes
      val capitalize : bytes -> bytes
      val uncapitalize : bytes -> bytes
      val uppercase_ascii : bytes -> bytes
      val lowercase_ascii : bytes -> bytes
      val capitalize_ascii : bytes -> bytes
      val uncapitalize_ascii : bytes -> bytes
      type t = bytes
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val unsafe_to_string : bytes -> string
      val unsafe_of_string : string -> bytes
      external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get"
      external unsafe_set : bytes -> int -> char -> unit
        = "%bytes_unsafe_set"
      external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit
        = "caml_blit_bytes" [@@noalloc]
      external unsafe_fill : bytes -> int -> int -> char -> unit
        = "caml_fill_bytes" [@@noalloc]
    end
  module Hashtbl :
    sig
      val create : ?random:bool -> int -> ('a, 'b) Hashtbl.t
      val clear : ('a, 'b) Hashtbl.t -> unit
      val reset : ('a, 'b) Hashtbl.t -> unit
      val copy : ('a, 'b) Hashtbl.t -> ('a, 'b) Hashtbl.t
      val add : ('a, 'b) Hashtbl.t -> '-> '-> unit
      val find : ('a, 'b) Hashtbl.t -> '-> 'b
      val find_opt : ('a, 'b) Hashtbl.t -> '-> 'b option
      val find_all : ('a, 'b) Hashtbl.t -> '-> 'b list
      val mem : ('a, 'b) Hashtbl.t -> '-> bool
      val remove : ('a, 'b) Hashtbl.t -> '-> unit
      val replace : ('a, 'b) Hashtbl.t -> '-> '-> unit
      val iter : ('-> '-> unit) -> ('a, 'b) Hashtbl.t -> unit
      val filter_map_inplace :
        ('-> '-> 'b option) -> ('a, 'b) Hashtbl.t -> unit
      val fold : ('-> '-> '-> 'c) -> ('a, 'b) Hashtbl.t -> '-> 'c
      val length : ('a, 'b) Hashtbl.t -> int
      val randomize : unit -> unit
      val is_randomized : unit -> bool
      val stats : ('a, 'b) Hashtbl.t -> Hashtbl.statistics
      module type HashedType =
        sig type t val equal : t -> t -> bool val hash : t -> int end
      module type S =
        sig
          type key
          type 'a t
          val create : int -> 'a t
          val clear : 'a t -> unit
          val reset : 'a t -> unit
          val copy : 'a t -> 'a t
          val add : 'a t -> key -> '-> unit
          val remove : 'a t -> key -> unit
          val find : 'a t -> key -> 'a
          val find_opt : 'a t -> key -> 'a option
          val find_all : 'a t -> key -> 'a list
          val replace : 'a t -> key -> '-> unit
          val mem : 'a t -> key -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val length : 'a t -> int
          val stats : 'a t -> Hashtbl.statistics
        end
      module Make :
        functor (H : HashedType->
          sig
            type key = H.t
            type 'a t
            val create : int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> '-> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> '-> unit
            val mem : 'a t -> key -> bool
            val iter : (key -> '-> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
          end
      module type SeededHashedType =
        sig type t val equal : t -> t -> bool val hash : int -> t -> int end
      module type SeededS =
        sig
          type key
          type 'a t
          val create : ?random:bool -> int -> 'a t
          val clear : 'a t -> unit
          val reset : 'a t -> unit
          val copy : 'a t -> 'a t
          val add : 'a t -> key -> '-> unit
          val remove : 'a t -> key -> unit
          val find : 'a t -> key -> 'a
          val find_opt : 'a t -> key -> 'a option
          val find_all : 'a t -> key -> 'a list
          val replace : 'a t -> key -> '-> unit
          val mem : 'a t -> key -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val length : 'a t -> int
          val stats : 'a t -> Hashtbl.statistics
        end
      module MakeSeeded :
        functor (H : SeededHashedType->
          sig
            type key = H.t
            type 'a t
            val create : ?random:bool -> int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> '-> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> '-> unit
            val mem : 'a t -> key -> bool
            val iter : (key -> '-> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
          end
      val hash : '-> int
      val seeded_hash : int -> '-> int
      val hash_param : int -> int -> '-> int
      val seeded_hash_param : int -> int -> int -> '-> int
    end
  module Queue :
    sig
      exception Empty
      val create : unit -> 'Queue.t
      val add : '-> 'Queue.t -> unit
      val push : '-> 'Queue.t -> unit
      val take : 'Queue.t -> 'a
      val pop : 'Queue.t -> 'a
      val peek : 'Queue.t -> 'a
      val top : 'Queue.t -> 'a
      val clear : 'Queue.t -> unit
      val copy : 'Queue.t -> 'Queue.t
      val is_empty : 'Queue.t -> bool
      val length : 'Queue.t -> int
      val iter : ('-> unit) -> 'Queue.t -> unit
      val fold : ('-> '-> 'b) -> '-> 'Queue.t -> 'b
      val transfer : 'Queue.t -> 'Queue.t -> unit
    end
  module Stack :
    sig
      exception Empty
      val create : unit -> 'Stack.t
      val push : '-> 'Stack.t -> unit
      val pop : 'Stack.t -> 'a
      val top : 'Stack.t -> 'a
      val clear : 'Stack.t -> unit
      val copy : 'Stack.t -> 'Stack.t
      val is_empty : 'Stack.t -> bool
      val length : 'Stack.t -> int
      val iter : ('-> unit) -> 'Stack.t -> unit
      val fold : ('-> '-> 'b) -> '-> 'Stack.t -> 'b
    end
  module Set :
    sig
      module type OrderedType = sig type t val compare : t -> t -> int end
      module type S =
        sig
          type elt
          type t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val map : (elt -> elt) -> t -> t
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_list : elt list -> t
        end
      module Make :
        functor (Ord : OrderedType->
          sig
            type elt = Ord.t
            type t
            val empty : t
            val is_empty : t -> bool
            val mem : elt -> t -> bool
            val add : elt -> t -> t
            val singleton : elt -> t
            val remove : elt -> t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val compare : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            val fold : (elt -> '-> 'a) -> t -> '-> 'a
            val for_all : (elt -> bool) -> t -> bool
            val exists : (elt -> bool) -> t -> bool
            val filter : (elt -> bool) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_list : elt list -> t
          end
    end
  module Map :
    sig
      module type OrderedType = sig type t val compare : t -> t -> int end
      module type S =
        sig
          type key
          type +'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
        end
      module Make :
        functor (Ord : OrderedType->
          sig
            type key = Ord.t
            type +'a t
            val empty : 'a t
            val is_empty : 'a t -> bool
            val mem : key -> 'a t -> bool
            val add : key -> '-> 'a t -> 'a t
            val singleton : key -> '-> 'a t
            val remove : key -> 'a t -> 'a t
            val merge :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val union :
              (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
            val iter : (key -> '-> unit) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val for_all : (key -> '-> bool) -> 'a t -> bool
            val exists : (key -> '-> bool) -> 'a t -> bool
            val filter : (key -> '-> bool) -> 'a t -> 'a t
            val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
            val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
            val min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          end
    end
  module Weak :
    sig
      val create : int -> 'Weak.t
      val length : 'Weak.t -> int
      val set : 'Weak.t -> int -> 'a option -> unit
      val get : 'Weak.t -> int -> 'a option
      val get_copy : 'Weak.t -> int -> 'a option
      val check : 'Weak.t -> int -> bool
      val fill : 'Weak.t -> int -> int -> 'a option -> unit
      val blit : 'Weak.t -> int -> 'Weak.t -> int -> int -> unit
      module type S =
        sig
          type data
          type t
          val create : int -> t
          val clear : t -> unit
          val merge : t -> data -> data
          val add : t -> data -> unit
          val remove : t -> data -> unit
          val find : t -> data -> data
          val find_opt : t -> data -> data option
          val find_all : t -> data -> data list
          val mem : t -> data -> bool
          val iter : (data -> unit) -> t -> unit
          val fold : (data -> '-> 'a) -> t -> '-> 'a
          val count : t -> int
          val stats : t -> int * int * int * int * int * int
        end
      module Make :
        functor (H : Hashtbl.HashedType->
          sig
            type data = H.t
            type t
            val create : int -> t
            val clear : t -> unit
            val merge : t -> data -> data
            val add : t -> data -> unit
            val remove : t -> data -> unit
            val find : t -> data -> data
            val find_opt : t -> data -> data option
            val find_all : t -> data -> data list
            val mem : t -> data -> bool
            val iter : (data -> unit) -> t -> unit
            val fold : (data -> '-> 'a) -> t -> '-> 'a
            val count : t -> int
            val stats : t -> int * int * int * int * int * int
          end
    end
  module Buffer :
    sig
      val create : int -> Buffer.t
      val contents : Buffer.t -> string
      val to_bytes : Buffer.t -> bytes
      val sub : Buffer.t -> int -> int -> string
      val blit : Buffer.t -> int -> bytes -> int -> int -> unit
      val nth : Buffer.t -> int -> char
      val length : Buffer.t -> int
      val clear : Buffer.t -> unit
      val reset : Buffer.t -> unit
      val add_char : Buffer.t -> char -> unit
      val add_string : Buffer.t -> string -> unit
      val add_bytes : Buffer.t -> bytes -> unit
      val add_substring : Buffer.t -> string -> int -> int -> unit
      val add_subbytes : Buffer.t -> bytes -> int -> int -> unit
      val add_substitute : Buffer.t -> (string -> string) -> string -> unit
      val add_buffer : Buffer.t -> Buffer.t -> unit
      val add_channel : Buffer.t -> in_channel -> int -> unit
      val output_buffer : out_channel -> Buffer.t -> unit
      val truncate : Buffer.t -> int -> unit
    end
  module Result :
    sig
      type ('a, 'b) result = ('a, 'b) Result.result = Ok of '| Error of 'b
    end
  module Printf :
    sig
      val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a
      val printf : ('a, out_channel, unit) format -> 'a
      val eprintf : ('a, out_channel, unit) format -> 'a
      val sprintf : ('a, unit, string) format -> 'a
      val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a
      val ifprintf : '-> ('a, 'b, 'c, unit) format4 -> 'a
      val kfprintf :
        (out_channel -> 'd) ->
        out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a
      val ikfprintf : ('-> 'd) -> '-> ('a, 'b, 'c, 'd) format4 -> 'a
      val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a
      val kbprintf :
        (Buffer.t -> 'd) ->
        Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a
      val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a
    end
  module Format :
    sig
      val open_box : int -> unit
      val close_box : unit -> unit
      val print_string : string -> unit
      val print_as : int -> string -> unit
      val print_int : int -> unit
      val print_float : float -> unit
      val print_char : char -> unit
      val print_bool : bool -> unit
      val print_space : unit -> unit
      val print_cut : unit -> unit
      val print_break : int -> int -> unit
      val print_flush : unit -> unit
      val print_newline : unit -> unit
      val force_newline : unit -> unit
      val print_if_newline : unit -> unit
      val set_margin : int -> unit
      val get_margin : unit -> int
      val set_max_indent : int -> unit
      val get_max_indent : unit -> int
      val set_max_boxes : int -> unit
      val get_max_boxes : unit -> int
      val over_max_boxes : unit -> bool
      val open_hbox : unit -> unit
      val open_vbox : int -> unit
      val open_hvbox : int -> unit
      val open_hovbox : int -> unit
      val set_ellipsis_text : string -> unit
      val get_ellipsis_text : unit -> string
      type tag = string
      val open_tag : tag -> unit
      val close_tag : unit -> unit
      val set_tags : bool -> unit
      val set_print_tags : bool -> unit
      val set_mark_tags : bool -> unit
      val get_print_tags : unit -> bool
      val get_mark_tags : unit -> bool
      val set_formatter_out_channel : out_channel -> unit
      val set_formatter_output_functions :
        (string -> int -> int -> unit) -> (unit -> unit) -> unit
      val get_formatter_output_functions :
        unit -> (string -> int -> int -> unit) * (unit -> unit)
      val set_formatter_out_functions :
        Format.formatter_out_functions -> unit
      val get_formatter_out_functions :
        unit -> Format.formatter_out_functions
      val set_formatter_tag_functions :
        Format.formatter_tag_functions -> unit
      val get_formatter_tag_functions :
        unit -> Format.formatter_tag_functions
      val formatter_of_out_channel : out_channel -> Format.formatter
      val std_formatter : Format.formatter
      val err_formatter : Format.formatter
      val formatter_of_buffer : Buffer.t -> Format.formatter
      val stdbuf : Buffer.t
      val str_formatter : Format.formatter
      val flush_str_formatter : unit -> string
      val make_formatter :
        (string -> int -> int -> unit) -> (unit -> unit) -> Format.formatter
      val pp_open_hbox : Format.formatter -> unit -> unit
      val pp_open_vbox : Format.formatter -> int -> unit
      val pp_open_hvbox : Format.formatter -> int -> unit
      val pp_open_hovbox : Format.formatter -> int -> unit
      val pp_open_box : Format.formatter -> int -> unit
      val pp_close_box : Format.formatter -> unit -> unit
      val pp_open_tag : Format.formatter -> string -> unit
      val pp_close_tag : Format.formatter -> unit -> unit
      val pp_print_string : Format.formatter -> string -> unit
      val pp_print_as : Format.formatter -> int -> string -> unit
      val pp_print_int : Format.formatter -> int -> unit
      val pp_print_float : Format.formatter -> float -> unit
      val pp_print_char : Format.formatter -> char -> unit
      val pp_print_bool : Format.formatter -> bool -> unit
      val pp_print_break : Format.formatter -> int -> int -> unit
      val pp_print_cut : Format.formatter -> unit -> unit
      val pp_print_space : Format.formatter -> unit -> unit
      val pp_force_newline : Format.formatter -> unit -> unit
      val pp_print_flush : Format.formatter -> unit -> unit
      val pp_print_newline : Format.formatter -> unit -> unit
      val pp_print_if_newline : Format.formatter -> unit -> unit
      val pp_set_tags : Format.formatter -> bool -> unit
      val pp_set_print_tags : Format.formatter -> bool -> unit
      val pp_set_mark_tags : Format.formatter -> bool -> unit
      val pp_get_print_tags : Format.formatter -> unit -> bool
      val pp_get_mark_tags : Format.formatter -> unit -> bool
      val pp_set_margin : Format.formatter -> int -> unit
      val pp_get_margin : Format.formatter -> unit -> int
      val pp_set_max_indent : Format.formatter -> int -> unit
      val pp_get_max_indent : Format.formatter -> unit -> int
      val pp_set_max_boxes : Format.formatter -> int -> unit
      val pp_get_max_boxes : Format.formatter -> unit -> int
      val pp_over_max_boxes : Format.formatter -> unit -> bool
      val pp_set_ellipsis_text : Format.formatter -> string -> unit
      val pp_get_ellipsis_text : Format.formatter -> unit -> string
      val pp_set_formatter_out_channel :
        Format.formatter -> out_channel -> unit
      val pp_set_formatter_output_functions :
        Format.formatter ->
        (string -> int -> int -> unit) -> (unit -> unit) -> unit
      val pp_get_formatter_output_functions :
        Format.formatter ->
        unit -> (string -> int -> int -> unit) * (unit -> unit)
      val pp_set_formatter_tag_functions :
        Format.formatter -> Format.formatter_tag_functions -> unit
      val pp_get_formatter_tag_functions :
        Format.formatter -> unit -> Format.formatter_tag_functions
      val pp_set_formatter_out_functions :
        Format.formatter -> Format.formatter_out_functions -> unit
      val pp_get_formatter_out_functions :
        Format.formatter -> unit -> Format.formatter_out_functions
      val pp_flush_formatter : Format.formatter -> unit
      val pp_print_list :
        ?pp_sep:(Format.formatter -> unit -> unit) ->
        (Format.formatter -> '-> unit) ->
        Format.formatter -> 'a list -> unit
      val pp_print_text : Format.formatter -> string -> unit
      val fprintf :
        Format.formatter -> ('a, Format.formatter, unit) format -> 'a
      val printf : ('a, Format.formatter, unit) format -> 'a
      val eprintf : ('a, Format.formatter, unit) format -> 'a
      val sprintf : ('a, unit, string) format -> 'a
      val asprintf : ('a, Format.formatter, unit, string) format4 -> 'a
      val ifprintf :
        Format.formatter -> ('a, Format.formatter, unit) format -> 'a
      val kfprintf :
        (Format.formatter -> 'a) ->
        Format.formatter -> ('b, Format.formatter, unit, 'a) format4 -> 'b
      val ikfprintf :
        (Format.formatter -> 'a) ->
        Format.formatter -> ('b, Format.formatter, unit, 'a) format4 -> 'b
      val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
      val kasprintf :
        (string -> 'a) -> ('b, Format.formatter, unit, 'a) format4 -> 'b
      val bprintf : Buffer.t -> ('a, Format.formatter, unit) format -> 'a
      val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
      val set_all_formatter_output_functions :
        out:(string -> int -> int -> unit) ->
        flush:(unit -> unit) ->
        newline:(unit -> unit) -> spaces:(int -> unit) -> unit
      val get_all_formatter_output_functions :
        unit ->
        (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) *
        (int -> unit)
      val pp_set_all_formatter_output_functions :
        Format.formatter ->
        out:(string -> int -> int -> unit) ->
        flush:(unit -> unit) ->
        newline:(unit -> unit) -> spaces:(int -> unit) -> unit
      val pp_get_all_formatter_output_functions :
        Format.formatter ->
        unit ->
        (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) *
        (int -> unit)
      val pp_open_tbox : Format.formatter -> unit -> unit
      val pp_close_tbox : Format.formatter -> unit -> unit
      val pp_print_tbreak : Format.formatter -> int -> int -> unit
      val pp_set_tab : Format.formatter -> unit -> unit
      val pp_print_tab : Format.formatter -> unit -> unit
      val open_tbox : unit -> unit
      val close_tbox : unit -> unit
      val print_tbreak : int -> int -> unit
      val set_tab : unit -> unit
      val print_tab : unit -> unit
    end
end