`include module type of struct include Stdlib end`
`val raise : exn -> 'a`
`val raise_notrace : exn -> 'a`
`val invalid_arg : string -> 'a`
`val failwith : string -> 'a`
`exception Exit`
`exception Match_failure of string * int * int`
`exception Assert_failure of string * int * int`
`exception Invalid_argument of string`
`exception Failure of string`
`exception Not_found`
`exception Out_of_memory`
`exception Stack_overflow`
`exception Sys_error of string`
`exception End_of_file`
`exception Division_by_zero`
`exception Sys_blocked_io`
`exception Undefined_recursive_module of string * int * int`
`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 __LOC__ : string`
`val __FILE__ : string`
`val __LINE__ : int`
`val __MODULE__ : string`
`val __POS__ : string * int * int * int`
`val __FUNCTION__ : string`
`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 acosh : float -> float`
`val asinh : float -> float`
`val atanh : 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 fpclass = Stdlib.fpclass =`

1. `| FP_normal`
2. `| FP_subnormal`
3. `| FP_zero`
4. `| FP_infinite`
5. `| 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 in_channel = Stdlib.in_channel`
`type 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 open_flag = Stdlib.open_flag =`

1. `| Open_rdonly`
2. `| Open_wronly`
3. `| Open_append`
4. `| Open_creat`
5. `| Open_trunc`
6. `| Open_excl`
7. `| Open_binary`
8. `| Open_text`
9. `| 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`
`type !'a ref = 'a Stdlib.ref = {`

1. `mutable contents : 'a;`

`}`
`val ref : 'a -> 'a ref`
`val (!) : 'a ref -> 'a`
`val (:=) : 'a ref -> 'a -> unit`
`val incr : int ref -> unit`
`val decr : int ref -> unit`
`type (!'a, !'b) result = ('a, 'b) Stdlib.result =`

1. `| Ok of 'a`
2. `| Error of 'b`

`type (!'a, !'b, !'c, !'d, !'e, !'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6`
`type (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6`
`type (!'a, !'b, !'c) format = ('a, 'b, 'c, 'c) format4`
`val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string`
`val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6`
`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`
`val do_domain_local_at_exit : (unit -> unit) ref`
`module Atomic : sig ... end`
`module Bool : sig ... end`
`module BytesLabels : sig ... end`
`module Condition : sig ... end`
`module Domain : sig ... end`
`module Dynarray : sig ... end`
`module Pqueue : sig ... end`
`module Effect : sig ... end`
`module Ephemeron : sig ... end`
`module Float : sig ... end`
`module Fun : sig ... end`
`module Iarray : sig ... end`
`module In_channel : sig ... end`
`module Int : sig ... end`
`module Mutex : sig ... end`
`module Obj : sig ... end`
`module Option : sig ... end`
`module Out_channel : sig ... end`
`module Pair : sig ... end`
`module Repr : sig ... end`
`module Semaphore : sig ... end`
`module Type : sig ... end`
`module Uchar : sig ... end`
`module Unit : sig ... end`
`module Arg : sig ... end`
`module Array : sig ... end`
`module ArrayLabels : sig ... end`
`module Buffer : sig ... end`
`module Bytes : sig ... end`
`module Callback : sig ... end`
`module Char : sig ... end`
`module Complex : sig ... end`
`module Digest : sig ... end`
`module Either : sig ... end`
`module Filename : sig ... end`
`module Format : sig ... end`
`module Gc : sig ... end`
`module Genlex = Genlex`
`module Hashtbl : sig ... end`
`module Int32 : sig ... end`
`module Int64 : sig ... end`
`module Lazy : sig ... end`
`module Lexing : sig ... end`
`module List : sig ... end`
`module ListLabels : sig ... end`
`module Map : sig ... end`
`module Marshal : sig ... end`
`module MoreLabels : sig ... end`
`module Nativeint : sig ... end`
`module Oo : sig ... end`
`module Parsing : sig ... end`
`module Printexc : sig ... end`
`module Printf : sig ... end`
`module Queue : sig ... end`
`module Random : sig ... end`
`module Scanf : sig ... end`
`module Set : sig ... end`
`module Seq : sig ... end`
`module Stack : sig ... end`
`module StdLabels : sig ... end`
`module Stream = Stream`
`module String : sig ... end`
`module StringLabels : sig ... end`
`module Sys : sig ... end`
`module Weak : sig ... end`
`module Unix = Unix`
`module Num = Num`
`module Big_int = Big_int`
`module Bigarray : sig ... end`
`module Str = Str`
`module Result : sig ... end`