sig
  module List :
    sig
      val init : int -> (int -> 'a) -> 'a list
      val return : ('a -> 'b option) -> 'a list -> 'b
      val return_opt : ('a -> 'b option) -> 'a list -> 'b option
      val map_opt : ('a -> 'b option) -> 'a list -> 'b list
      val assoc_err : 'a -> ('a * 'b) list -> err:string -> 'b
      val assoc_def : 'a -> ('a * 'b) list -> def:'b -> 'b
      val assoc_replace : 'a -> 'b -> ('a * 'b) list -> ('a * 'b) list
      val take : int -> 'a list -> 'a list
      val drop : int -> 'a list -> 'a list
      val uniq : 'a list -> 'a list
      val index : 'a -> 'a list -> int list
      val starts_with : 'a list -> 'a list -> bool
      val length : 'a list -> int
      val hd : 'a list -> 'a
      val tl : 'a list -> 'a list
      val nth : 'a list -> int -> 'a
      val rev : 'a list -> 'a list
      val append : 'a list -> 'a list -> 'a list
      val rev_append : 'a list -> 'a list -> 'a list
      val concat : 'a list list -> 'a list
      val flatten : 'a list list -> 'a list
      val iter : ('a -> unit) -> 'a list -> unit
      val iteri : (int -> 'a -> unit) -> 'a list -> unit
      val map : ('a -> 'b) -> 'a list -> 'b list
      val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
      val rev_map : ('a -> 'b) -> 'a list -> 'b list
      val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
      val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
      val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
      val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
      val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
      val fold_left2 :
        ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
      val fold_right2 :
        ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
      val for_all : ('a -> bool) -> 'a list -> bool
      val exists : ('a -> bool) -> 'a list -> bool
      val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
      val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
      val mem : 'a -> 'a list -> bool
      val memq : 'a -> 'a list -> bool
      val find : ('a -> bool) -> 'a list -> 'a
      val filter : ('a -> bool) -> 'a list -> 'a list
      val find_all : ('a -> bool) -> 'a list -> 'a list
      val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
      val assoc : 'a -> ('a * 'b) list -> 'b
      val assq : 'a -> ('a * 'b) list -> 'b
      val mem_assoc : 'a -> ('a * 'b) list -> bool
      val mem_assq : 'a -> ('a * 'b) list -> bool
      val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
      val remove_assq : 'a -> ('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 : ('a -> 'a -> int) -> 'a list -> 'a list
      val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list
      val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list
      val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
    end
  module Array :
    sig
      val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
      external length : 'a array -> int = "%array_length"
      external get : 'a array -> int -> 'a = "%array_safe_get"
      external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
      external make : int -> 'a -> 'a array = "caml_make_vect"
      external create : int -> 'a -> 'a array = "caml_make_vect"
      val init : int -> (int -> 'a) -> 'a array
      val make_matrix : int -> int -> 'a -> 'a array array
      val create_matrix : int -> int -> 'a -> '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 -> 'a -> 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 : ('a -> unit) -> 'a array -> unit
      val map : ('a -> 'b) -> 'a array -> 'b array
      val iteri : (int -> 'a -> unit) -> 'a array -> unit
      val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
      val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
      val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
      val sort : ('a -> 'a -> int) -> 'a array -> unit
      val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
      val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
      external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
      external unsafe_set : 'a array -> int -> 'a -> unit
        = "%array_unsafe_set"
      external unsafe_blit :
        'a array -> int -> 'a array -> int -> int -> unit = "caml_array_blit"
    end
  module ImArray :
    sig
      type 'a t
      val map2 :
        ('a -> 'b -> 'c) ->
        'a UtilsLib.ImArray.t ->
        'b UtilsLib.ImArray.t -> 'c UtilsLib.ImArray.t
      external length : 'a UtilsLib.ImArray.t -> int = "%array_length"
      external get : 'a UtilsLib.ImArray.t -> int -> 'a = "%array_safe_get"
      external make : int -> 'a -> 'a UtilsLib.ImArray.t = "caml_make_vect"
      external create : int -> 'a -> 'a UtilsLib.ImArray.t = "caml_make_vect"
      val init : int -> (int -> 'a) -> 'a UtilsLib.ImArray.t
      val make_matrix :
        int -> int -> 'a -> 'a UtilsLib.ImArray.t UtilsLib.ImArray.t
      val create_matrix :
        int -> int -> 'a -> 'a UtilsLib.ImArray.t UtilsLib.ImArray.t
      val append :
        'a UtilsLib.ImArray.t ->
        'a UtilsLib.ImArray.t -> 'a UtilsLib.ImArray.t
      val concat : 'a UtilsLib.ImArray.t list -> 'a UtilsLib.ImArray.t
      val sub : 'a UtilsLib.ImArray.t -> int -> int -> 'a UtilsLib.ImArray.t
      val copy : 'a UtilsLib.ImArray.t -> 'a UtilsLib.ImArray.t
      val to_list : 'a UtilsLib.ImArray.t -> 'a list
      val of_list : 'a list -> 'a UtilsLib.ImArray.t
      val iter : ('a -> unit) -> 'a UtilsLib.ImArray.t -> unit
      val map : ('a -> 'b) -> 'a UtilsLib.ImArray.t -> 'b UtilsLib.ImArray.t
      val iteri : (int -> 'a -> unit) -> 'a UtilsLib.ImArray.t -> unit
      val mapi :
        (int -> 'a -> 'b) -> 'a UtilsLib.ImArray.t -> 'b UtilsLib.ImArray.t
      val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b UtilsLib.ImArray.t -> 'a
      val fold_right : ('b -> 'a -> 'a) -> 'b UtilsLib.ImArray.t -> 'a -> 'a
      val sort :
        ('a -> 'a -> int) -> 'a UtilsLib.ImArray.t -> 'a UtilsLib.ImArray.t
      val stable_sort :
        ('a -> 'a -> int) -> 'a UtilsLib.ImArray.t -> 'a UtilsLib.ImArray.t
      val fast_sort :
        ('a -> 'a -> int) -> 'a UtilsLib.ImArray.t -> 'a UtilsLib.ImArray.t
      external unsafe_get : 'a UtilsLib.ImArray.t -> int -> 'a
        = "%array_unsafe_get"
    end
  module String :
    sig
      val init : int -> (int -> char) -> string
      val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a
      val nth : string -> int -> char option
      val nth_is : string -> int -> char -> bool
      val char_rindex_from : string -> int -> char -> int option
      val char_index_from : string -> int -> char -> int option
      val char_index_all : string -> char -> int list
      val char_split : char -> string -> string list
      val char_splitter : char -> string -> string list
      val char_cut : char -> string -> (string * string) option
      val char_rcut : char -> string -> (string * string) option
      val starts_with : string -> string -> bool
      val ends_with : string -> string -> bool
      val str_split : string -> string -> string list
      val str_cut : string -> string -> (string * string) option
      val string_index : string -> string -> int option
      val string_rindex : string -> string -> int option
      val string_index_from : string -> int -> string -> int option
      val string_rindex_from : string -> int -> string -> int option
      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 iteri : (int -> char -> unit) -> string -> unit
      val map : (char -> char) -> string -> string
      val trim : string -> string
      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 : UtilsLib.String.t -> UtilsLib.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"
    end
  module ImString :
    sig
      type t
      val to_string : UtilsLib.ImString.t -> string
      val of_string : string -> UtilsLib.ImString.t
      val init : int -> (int -> char) -> UtilsLib.ImString.t
      val fold_left : ('a -> char -> 'a) -> 'a -> UtilsLib.ImString.t -> 'a
      val nth : UtilsLib.ImString.t -> int -> char option
      val nth_is : UtilsLib.ImString.t -> int -> char -> bool
      val char_rindex_from : UtilsLib.ImString.t -> int -> char -> int option
      val char_index_from : UtilsLib.ImString.t -> int -> char -> int option
      val char_index_all : UtilsLib.ImString.t -> char -> int list
      val char_split :
        char -> UtilsLib.ImString.t -> UtilsLib.ImString.t list
      val char_splitter :
        char -> UtilsLib.ImString.t -> UtilsLib.ImString.t list
      val char_cut :
        char ->
        UtilsLib.ImString.t ->
        (UtilsLib.ImString.t * UtilsLib.ImString.t) option
      val char_rcut :
        char ->
        UtilsLib.ImString.t ->
        (UtilsLib.ImString.t * UtilsLib.ImString.t) option
      val starts_with : UtilsLib.ImString.t -> UtilsLib.ImString.t -> bool
      val ends_with : UtilsLib.ImString.t -> UtilsLib.ImString.t -> bool
      val str_split :
        UtilsLib.ImString.t ->
        UtilsLib.ImString.t -> UtilsLib.ImString.t list
      val str_cut :
        UtilsLib.ImString.t ->
        UtilsLib.ImString.t ->
        (UtilsLib.ImString.t * UtilsLib.ImString.t) option
      val string_index :
        UtilsLib.ImString.t -> UtilsLib.ImString.t -> int option
      val string_rindex :
        UtilsLib.ImString.t -> UtilsLib.ImString.t -> int option
      val string_index_from :
        UtilsLib.ImString.t -> int -> UtilsLib.ImString.t -> int option
      val string_rindex_from :
        UtilsLib.ImString.t -> int -> UtilsLib.ImString.t -> int option
      external length : UtilsLib.ImString.t -> int = "%string_length"
      external get : UtilsLib.ImString.t -> int -> char = "%string_safe_get"
      val make : int -> char -> UtilsLib.ImString.t
      val copy : UtilsLib.ImString.t -> UtilsLib.ImString.t
      val sub : UtilsLib.ImString.t -> int -> int -> UtilsLib.ImString.t
      val blit : UtilsLib.ImString.t -> int -> string -> int -> int -> unit
      val concat :
        UtilsLib.ImString.t ->
        UtilsLib.ImString.t list -> UtilsLib.ImString.t
      val iter : (char -> unit) -> UtilsLib.ImString.t -> unit
      val iteri : (int -> char -> unit) -> UtilsLib.ImString.t -> unit
      val map : (char -> char) -> UtilsLib.ImString.t -> UtilsLib.ImString.t
      val trim : UtilsLib.ImString.t -> UtilsLib.ImString.t
      val escaped : UtilsLib.ImString.t -> UtilsLib.ImString.t
      val index : UtilsLib.ImString.t -> char -> int
      val rindex : UtilsLib.ImString.t -> char -> int
      val index_from : UtilsLib.ImString.t -> int -> char -> int
      val rindex_from : UtilsLib.ImString.t -> int -> char -> int
      val contains : UtilsLib.ImString.t -> char -> bool
      val contains_from : UtilsLib.ImString.t -> int -> char -> bool
      val rcontains_from : UtilsLib.ImString.t -> int -> char -> bool
      val uppercase : UtilsLib.ImString.t -> UtilsLib.ImString.t
      val lowercase : UtilsLib.ImString.t -> UtilsLib.ImString.t
      val capitalize : UtilsLib.ImString.t -> UtilsLib.ImString.t
      val uncapitalize : UtilsLib.ImString.t -> UtilsLib.ImString.t
      val compare : UtilsLib.ImString.t -> UtilsLib.ImString.t -> int
      external unsafe_get : UtilsLib.ImString.t -> int -> char
        = "%string_unsafe_get"
      external unsafe_blit :
        UtilsLib.ImString.t -> int -> string -> int -> int -> unit
        = "caml_blit_string" "noalloc"
    end
  module Char :
    sig
      val is_alpha : char -> bool
      val is_num : char -> bool
      val is_alpha_num : char -> bool
      val is_hex_num : char -> bool
      external code : char -> int = "%identity"
      val chr : int -> char
      val escaped : char -> string
      val lowercase : char -> char
      val uppercase : char -> char
      type t = char
      val compare : UtilsLib.Char.t -> UtilsLib.Char.t -> int
      external unsafe_chr : int -> char = "%identity"
    end
  module Input :
    sig
      type t = Pervasives.in_channel
      val read_file : string -> string
      val read_file_bin : string -> string
      val input_channel : UtilsLib.Input.t -> string
      val input_line : UtilsLib.Input.t -> string option
      val input_lines : UtilsLib.Input.t -> string list
      val lines_of_file : string -> string list
      val line : UtilsLib.Input.t -> string option
      val lines : UtilsLib.Input.t -> string list
    end
  module Output :
    sig
      type t = Pervasives.out_channel
      val write_file : string -> string -> unit
      val write_file_bin : string -> string -> unit
      module Infix :
        sig val ( << ) : Pervasives.out_channel -> string -> unit end
    end
  module Sys :
    sig
      val args : string list
      val argv : string array
      val executable_name : string
      external file_exists : string -> bool = "caml_sys_file_exists"
      external is_directory : string -> bool = "caml_sys_is_directory"
      external remove : string -> unit = "caml_sys_remove"
      external rename : string -> string -> unit = "caml_sys_rename"
      external getenv : string -> string = "caml_sys_getenv"
      external command : string -> int = "caml_sys_system_command"
      external time : unit -> float = "caml_sys_time"
      external chdir : string -> unit = "caml_sys_chdir"
      external getcwd : unit -> string = "caml_sys_getcwd"
      external readdir : string -> string array = "caml_sys_read_directory"
      val interactive : bool Pervasives.ref
      val os_type : string
      val word_size : int
      val big_endian : bool
      val max_string_length : int
      val max_array_length : int
      type signal_behavior =
        Sys.signal_behavior =
          Signal_default
        | Signal_ignore
        | Signal_handle of (int -> unit)
      external signal :
        int -> UtilsLib.Sys.signal_behavior -> UtilsLib.Sys.signal_behavior
        = "caml_install_signal_handler"
      val set_signal : int -> UtilsLib.Sys.signal_behavior -> unit
      val sigabrt : int
      val sigalrm : int
      val sigfpe : int
      val sighup : int
      val sigill : int
      val sigint : int
      val sigkill : int
      val sigpipe : int
      val sigquit : int
      val sigsegv : int
      val sigterm : int
      val sigusr1 : int
      val sigusr2 : int
      val sigchld : int
      val sigcont : int
      val sigstop : int
      val sigtstp : int
      val sigttin : int
      val sigttou : int
      val sigvtalrm : int
      val sigprof : int
      exception Break
      val catch_break : bool -> unit
      val ocaml_version : string
    end
  module Loop :
    sig
      val fold_left : ('a -> int -> 'a) -> 'a -> int -> 'a
      val iter : (unit -> unit) -> int -> unit
      val iteri : (int -> unit) -> int -> unit
    end
  module Random :
    sig
      val init_bak : unit -> string
      val bak_init : string -> unit
      val prob_take : ('a -> float) -> 'a list -> 'a
      val prob_extract : ('a -> float) -> 'a list -> 'a * 'a list
      val init : int -> unit
      val full_init : int array -> unit
      val self_init : unit -> unit
      val bits : unit -> int
      val int : int -> int
      val int32 : Int32.t -> Int32.t
      val nativeint : Nativeint.t -> Nativeint.t
      val int64 : Int64.t -> Int64.t
      val float : float -> float
      val bool : unit -> bool
      module State :
        sig
          type t = Random.State.t
          val make : int array -> UtilsLib.Random.State.t
          val make_self_init : unit -> UtilsLib.Random.State.t
          val copy : UtilsLib.Random.State.t -> UtilsLib.Random.State.t
          val bits : UtilsLib.Random.State.t -> int
          val int : UtilsLib.Random.State.t -> int -> int
          val int32 : UtilsLib.Random.State.t -> Int32.t -> Int32.t
          val nativeint :
            UtilsLib.Random.State.t -> Nativeint.t -> Nativeint.t
          val int64 : UtilsLib.Random.State.t -> Int64.t -> Int64.t
          val float : UtilsLib.Random.State.t -> float -> float
          val bool : UtilsLib.Random.State.t -> bool
        end
      val get_state : unit -> UtilsLib.Random.State.t
      val set_state : UtilsLib.Random.State.t -> unit
      module Int : sig val range : int -> int -> int end
      module Float : sig val range : float -> float -> float end
      module Int32 : sig val range : int32 -> int32 -> int32 end
      module Int64 : sig val range : int64 -> int64 -> int64 end
      module List : sig val take : 'a list -> 'a end
      module Array : sig val take : 'a array -> 'a end
    end
  module RandState :
    sig
      val make_init_bak : unit -> UtilsLib.Random.State.t * string
      val make_bak_init : string -> UtilsLib.Random.State.t
    end
  module Int :
    sig
      type t = int
      val compare : UtilsLib.Int.t -> UtilsLib.Int.t -> int
      val rand : UtilsLib.Int.t -> UtilsLib.Int.t
    end
  module Float :
    sig
      type t = float
      val compare : UtilsLib.Float.t -> UtilsLib.Float.t -> int
      val rand : UtilsLib.Float.t -> UtilsLib.Float.t
      val cmp_float : ?epsilon_float:float -> unit -> float -> float -> bool
      module Infix :
        sig
          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_fmod_float" "fmod"
            "float"
          external ( ** ) : float -> float -> float = "caml_power_float"
            "pow" "float"
          val ( < ) : float -> float -> bool
          val ( > ) : float -> float -> bool
          val ( = ) : float -> float -> bool
          val ( <= ) : float -> float -> bool
          val ( >= ) : float -> float -> bool
        end
      module InfixDot :
        sig
          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_fmod_float"
            "fmod" "float"
          external ( **. ) : float -> float -> float = "caml_power_float"
            "pow" "float"
          val ( <. ) : float -> float -> bool
          val ( >. ) : float -> float -> bool
          val ( =. ) : float -> float -> bool
          val ( <=. ) : float -> float -> bool
          val ( >=. ) : float -> float -> bool
        end
    end
  module Int32 :
    sig
      type t = int32
      val range : UtilsLib.Int32.t -> UtilsLib.Int32.t -> UtilsLib.Int32.t
      module Infix :
        sig
          external ( + ) : int32 -> int32 -> int32 = "%int32_add"
          external ( - ) : int32 -> int32 -> int32 = "%int32_sub"
          external ( * ) : int32 -> int32 -> int32 = "%int32_mul"
          external ( / ) : int32 -> int32 -> int32 = "%int32_div"
          external ( << ) : int64 -> int -> int64 = "%int32_lsl"
          external ( >> ) : int64 -> int -> int64 = "%int32_asr"
        end
      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"
      val compare : UtilsLib.Int32.t -> UtilsLib.Int32.t -> int
    end
  module Int64 :
    sig
      type t = int64
      val range : UtilsLib.Int64.t -> UtilsLib.Int64.t -> UtilsLib.Int64.t
      module Infix :
        sig
          external ( + ) : int64 -> int64 -> int64 = "%int64_add"
          external ( - ) : int64 -> int64 -> int64 = "%int64_sub"
          external ( * ) : int64 -> int64 -> int64 = "%int64_mul"
          external ( / ) : int64 -> int64 -> int64 = "%int64_div"
          external ( << ) : int64 -> int -> int64 = "%int64_lsl"
          external ( >> ) : int64 -> int -> int64 = "%int64_asr"
        end
      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"
      val compare : UtilsLib.Int64.t -> UtilsLib.Int64.t -> int
    end
  module Args :
    sig
      type kind =
          Int
        | Float
        | String
        | Set_true
        | Set_false
        | Custom of string
        | StringAcc
      type p =
          Default of string
        | Defaults of string list
        | Required
        | Optional
      type spec = string * UtilsLib.Args.p * UtilsLib.Args.kind * string
      type args = string list
      type cmd
      val parse :
        UtilsLib.Args.spec list -> UtilsLib.Args.args -> UtilsLib.Args.cmd
      val usage : UtilsLib.Args.spec list -> unit
      val get_int : UtilsLib.Args.cmd -> string -> int
      val get_float : UtilsLib.Args.cmd -> string -> float
      val get_bool : UtilsLib.Args.cmd -> string -> bool
      val get_string : UtilsLib.Args.cmd -> string -> string
      val get_custom : (string -> 'a) -> UtilsLib.Args.cmd -> string -> 'a
      val get_string_list : UtilsLib.Args.cmd -> string -> string list
      val get_int_opt : UtilsLib.Args.cmd -> string -> int option
      val get_float_opt : UtilsLib.Args.cmd -> string -> float option
      val get_bool_opt : UtilsLib.Args.cmd -> string -> bool option
      val get_string_opt : UtilsLib.Args.cmd -> string -> string option
      val get_custom_opt :
        (string -> 'a) -> UtilsLib.Args.cmd -> string -> 'a option
    end
  module Option : sig val default : 'a -> 'a option -> 'a end
  module Labels :
    sig
      module Loop :
        sig
          val fold_left : f:('a -> int -> 'a) -> init:'a -> int -> 'a
          val iter : f:(unit -> 'a) -> int -> unit
          val iteri : f:(int -> 'a) -> int -> unit
        end
    end
end