Module Base__.Import0

include module type of sig ... end with type 'a ref := 'a Stdlib.ref with type ('a, 'b, 'c) format := ('a, 'b, 'c) Stdlib.format with type ('a, 'b, 'c, 'd) format4 := ('a, 'b, 'c, 'd) Stdlib.format4 with type ('a, 'b, 'c, 'd, 'e, 'f) format6 := ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 with module Array := Shadow_stdlib.Array with module Bool := Shadow_stdlib.Bool with module Buffer := Shadow_stdlib.Buffer with module Bytes := Shadow_stdlib.Bytes with module Char := Shadow_stdlib.Char with module Float := Shadow_stdlib.Float with module Hashtbl := Shadow_stdlib.Hashtbl with module Int := Shadow_stdlib.Int with module Int32 := Shadow_stdlib.Int32 with module Int64 := Shadow_stdlib.Int64 with module Lazy := Shadow_stdlib.Lazy with module List := Shadow_stdlib.List with module Map := Shadow_stdlib.Map with module Nativeint := Shadow_stdlib.Nativeint with module Option := Shadow_stdlib.Option with module Printf := Shadow_stdlib.Printf with module Queue := Shadow_stdlib.Queue with module Random := Shadow_stdlib.Random with module Result := Shadow_stdlib.Result with module Set := Shadow_stdlib.Set with module Stack := Shadow_stdlib.Stack with module String := Shadow_stdlib.String with module Sys := Shadow_stdlib.Sys with module Uchar := Shadow_stdlib.Uchar with module Unit := Shadow_stdlib.Unit
val raise : exn -> 'a
val raise_notrace : exn -> 'a
val invalid_arg : string -> 'a
val failwith : string -> 'a
exception Exit
val (=) : 'a -> 'a -> bool
val (<>) : 'a -> 'a -> bool
val (<) : 'a -> 'a -> bool
val (>) : 'a -> 'a -> bool
val (<=) : 'a -> 'a -> bool
val (>=) : 'a -> 'a -> bool
val compare : 'a -> 'a -> int
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (|>) : 'a -> ('a -> 'b) -> 'b
val (@@) : ('a -> 'b) -> 'a -> 'b
val (~-) : int -> int
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val max_int : int
val min_int : int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val (lnot) : int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (asr) : int -> int -> int
val (~-.) : float -> float
val (~+.) : float -> float
val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val infinity : float
val neg_infinity : float
val nan : float
val max_float : float
val min_float : float
val epsilon_float : float
type nonrec fpclass = Stdlib.fpclass =
| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan
val classify_float : float -> fpclass
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val ignore : 'a -> unit
val string_of_bool : bool -> string
val bool_of_string_opt : string -> bool option
val bool_of_string : string -> bool
val string_of_int : int -> string
val int_of_string_opt : string -> int option
val int_of_string : string -> int
val string_of_float : float -> string
val float_of_string_opt : string -> float option
val float_of_string : string -> float
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
val (@) : 'a list -> 'a list -> 'a list
type nonrec in_channel = Stdlib.in_channel
type nonrec out_channel = Stdlib.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_opt : unit -> int option
val read_int : unit -> int
val read_float_opt : unit -> float option
val read_float : unit -> float
type nonrec open_flag = Stdlib.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 -> 'a -> 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 = Stdlib.LargeFile
val ref : 'a -> 'a Stdlib.ref
val (!) : 'a Stdlib.ref -> 'a
val (:=) : 'a Stdlib.ref -> 'a -> unit
val incr : 'a Stdlib.ref -> unit
val decr : 'a Stdlib.ref -> unit
type nonrec ('a, 'b) result = ('a, 'b) Stdlib.result =
| Ok of 'a
| Error of 'b
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.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 Arg : sig ... end

Parsing of command line arguments.

module ArrayLabels : sig ... end
module BytesLabels : sig ... end

Byte sequence operations.

module Callback : sig ... end

Registering OCaml values with the C runtime.

module Complex : sig ... end

Complex numbers.

module Digest : sig ... end

MD5 message digest.

module Ephemeron : sig ... end

Ephemerons and weak hash table

module Filename : sig ... end

Operations on file names.

module Format : sig ... end

Pretty-printing.

module Fun : sig ... end

Function manipulation.

module Gc : sig ... end

Memory management control and statistics; finalised values.

module Genlex : sig ... end

A generic lexical analyzer.

module Lexing : sig ... end

The run-time library for lexers generated by ocamllex.

module ListLabels : sig ... end
module Marshal : sig ... end

Marshaling of data structures.

module MoreLabels : sig ... end

Extra labeled libraries.

module Obj : sig ... end

Operations on internal representations of values.

module Oo : sig ... end

Operations on objects

module Parsing : sig ... end

The run-time library for parsers generated by ocamlyacc.

module Pervasives : sig ... end
module Printexc : sig ... end

Facilities for printing exceptions and inspecting current call stack.

module Scanf : sig ... end

Formatted input functions.

module Seq : sig ... end
module Spacetime : sig ... end

Profiling of a program's space behaviour over time. Currently only supported on x86-64 platforms running 64-bit code.

module StdLabels : sig ... end

Standard labeled libraries.

module Stream : sig ... end

Streams and parsers.

module StringLabels : sig ... end

String operations.

module Weak : sig ... end

Arrays of weak pointers and hash sets of weak pointers.

exception Not_found
type 'a ref = 'a Caml.ref = {
mutable contents : 'a;
}
module Caml : sig ... end
val (|>) : 'a -> ('a -> 'b) -> 'b
val (&&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val not : bool -> bool
val bool_to_int : bool -> int
val ignore : _ -> unit
val (!=) : 'a -> 'a -> bool
val (*) : int -> int -> int
val (**) : float -> float -> float
val (*.) : float -> float -> float
val (+) : int -> int -> int
val (+.) : float -> float -> float
val (-) : int -> int -> int
val (-.) : float -> float -> float
val (/) : int -> int -> int
val (/.) : float -> float -> float
module Poly : sig ... end
module Int_replace_polymorphic_compare : sig ... end
include Int_replace_polymorphic_compare
val (<) : int -> int -> bool
val (<=) : int -> int -> bool
val (<>) : int -> int -> bool
val (=) : int -> int -> bool
val (>) : int -> int -> bool
val (>=) : int -> int -> bool
val compare : int -> int -> int
val ascending : int -> int -> int
val descending : int -> int -> int
val equal : int -> int -> bool
val max : int -> int -> int
val min : int -> int -> int
module Int32_replace_polymorphic_compare : sig ... end
module Int64_replace_polymorphic_compare : sig ... end
module Nativeint_replace_polymorphic_compare : sig ... end
module Bool_replace_polymorphic_compare : sig ... end
module Char_replace_polymorphic_compare : sig ... end
module Uchar_replace_polymorphic_compare : sig ... end
module Float_replace_polymorphic_compare : sig ... end
module String_replace_polymorphic_compare : sig ... end
module Bytes_replace_polymorphic_compare : sig ... end
val (:=) : 'a ref -> 'a -> unit
val (!) : 'a ref -> 'a
val ref : 'a -> 'a ref
val (@) : 'a list -> 'a list -> 'a list
val (^) : string -> string -> string
val (~-) : int -> int
val (~-.) : float -> float
val (asr) : int -> int -> int
val (land) : int -> int -> int
val (lnot) : int -> int
val (lor) : int -> int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (lxor) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val failwith : string -> 'a
val fst : ('a * 'b) -> 'a
val invalid_arg : string -> 'a
val snd : ('a * 'b) -> 'b
val raise : exn -> _
val phys_equal : 'a -> 'a -> bool
val decr : int Caml.ref -> unit
val incr : int Caml.ref -> unit
val float_of_string : string -> float
val am_testing : unit -> bool
val am_testing : bool