`include Core`
`module Std = Core__.Std0`
`module Applicative = Core_kernel__.Import.Applicative`
`module Avltree = Core_kernel__.Import.Avltree`
`module Backtrace = Core_kernel__.Import.Backtrace`
`module Bin_prot = Core_kernel__.Core_bin_prot`
`module Binary_search = Core_kernel__.Import.Binary_search`
`module Commutative_group = Core_kernel__.Import.Commutative_group`
`module Comparisons = Core_kernel__.Import.Comparisons`
`module Equal = Core_kernel__.Import.Equal`
`module Exn = Base.Exn`
`module Expect_test_config = Expect_test_config`
`module Field = Core_kernel__.Import.Field`
`module Floatable = Core_kernel__.Import.Floatable`
`module Hash = Core_kernel__.Import.Hash`
`module Heap_block = Core_kernel__.Import.Heap_block`
`module In_channel = Core_kernel__.Import.In_channel`
`module Int_conversions = Base.Not_exposed_properly.Int_conversions`
`module Invariant = Core_kernel__.Import.Invariant`
`module Monad = Core_kernel__.Import.Monad`
`module Obj_array = Base.Not_exposed_properly.Obj_array`
`module Ordered_collection_common = Core_kernel__.Ordered_collection_common`
`module Out_channel = Core_kernel__.Import.Out_channel`
`module Poly = Core_kernel__.Import.Poly`
`module Polymorphic_compare = Core_kernel__.Import.Polymorphic_compare`
`module Pretty_printer = Core_kernel__.Import.Pretty_printer`
`module Random = Base.Random`
`module Sexp_maybe = Core_kernel__.Sexp.Sexp_maybe`
`module Staged = Base.Staged`
`module Stringable = Core_kernel__.Import.Stringable`
`module Validate = Core_kernel__.Import.Validate`
`module With_return = Core_kernel__.Import.With_return`
`module Word_size = Core_kernel__.Import.Word_size`
`module Array = Core_kernel__.Array`
`module Binary_searchable = Core_kernel__.Binary_searchable`
`module Blit = Core_kernel__.Blit`
`module Bool = Core_kernel__.Bool`
`module Bytes = Core_kernel__.Bytes`
`module Char = Core_kernel__.Char`
`module Comparable = Core_kernel__.Comparable`
`module Comparator = Core_kernel__.Comparator`
`module Container = Core_kernel__.Container`
`module Either = Core_kernel__.Either`
`module Error = Core_kernel__.Error`
`module Float = Core_kernel__.Float`
`module Fn = Core_kernel__.Fn`
`module Hash_set = Core_kernel__.Hash_set`
`module Hashtbl = Core_kernel__.Hashtbl`
`module Hashtbl_intf = Core_kernel__.Hashtbl_intf`
`module Info = Core_kernel__.Info`
`module Int = Core_kernel__.Int`
`module Int_intf = Core_kernel__.Int_intf`
`module Int32 = Core_kernel__.Int32`
`module Int63 = Core_kernel__.Int63`
`module Int64 = Core_kernel__.Int64`
`module Lazy = Core_kernel__.Lazy`
`module Linked_queue = Core_kernel__.Linked_queue`
`module List = Core_kernel__.List`
`module Maybe_bound = Core_kernel__.Maybe_bound`
`module Nativeint = Core_kernel__.Nativeint`
`module Option = Core_kernel__.Option`
`module Ordering = Core_kernel__.Ordering`
`module Or_error = Core_kernel__.Or_error`
`module Printf = Core_kernel__.Printf`
`module Ref = Core_kernel__.Ref`
`module Result = Core_kernel__.Result`
`module Sequence = Core_kernel__.Sequence`
`module Set = Core_kernel__.Set`
`module Sexp = Core_kernel__.Sexp`
`module Sexpable = Core_kernel__.Sexpable`
`module Sign = Core_kernel__.Sign`
`module Source_code_position = Core_kernel__.Source_code_position`
`module String = Core_kernel__.String`
`module Type_equal = Core_kernel__.Type_equal`
`module Unit = Core_kernel__.Unit`
`module Arg = Core_kernel__.Arg`
`module Bag = Core_kernel__.Bag`
`module Bigsubstring = Core_kernel__.Bigsubstring`
`module Binable = Core_kernel__.Binable`
`module Binary_packing = Core_kernel__.Binary_packing`
`module Blang = Core_kernel__.Blang`
`module Bounded_index = Core_kernel__.Bounded_index`
`module Bounded_int_table = Core_kernel__.Bounded_int_table`
`module Bucket = Core_kernel__.Bucket`
`module Bus = Core_kernel__.Bus`
`module Byte_units = Core_kernel__.Byte_units`
`module Day_of_week = Core_kernel__.Day_of_week`
`module Debug = Core_kernel__.Debug`
`module Deque = Core_kernel__.Deque`
`module Deriving_hash = Core_kernel__.Deriving_hash`
`module Doubly_linked = Core_kernel__.Doubly_linked`
`module Ephemeron = Core_kernel__.Ephemeron`
`module Fdeque = Core_kernel__.Fdeque`
`module Fheap = Core_kernel__.Fheap`
`module Flags = Core_kernel__.Flags`
`module Float_with_finite_only_serialization = Core_kernel__.Float_with_finite_only_serialization`
`module Force_once = Core_kernel__.Force_once`
`module Fqueue = Core_kernel__.Fqueue`
`module Gc = Core_kernel__.Gc`
`module Hash_heap = Core_kernel__.Hash_heap`
`module Hash_queue = Core_kernel__.Hash_queue`
`module Hashable = Core_kernel__.Hashable`
`module Heap = Core_kernel__.Heap`
`module Hexdump = Core_kernel__.Hexdump`
`module Hexdump_intf = Core_kernel__.Hexdump_intf`
`module Host_and_port = Core_kernel__.Host_and_port`
`module Identifiable = Core_kernel__.Identifiable`
`module Immediate_option = Core_kernel__.Immediate_option`
`module Immediate_option_intf = Core_kernel__.Immediate_option_intf`
`module Int_set = Core_kernel__.Int_set`
`module Interfaces = Core_kernel__.Interfaces`
`module Limiter = Core_kernel__.Limiter`
`module Linked_stack = Core_kernel__.Linked_stack`
`module Map = Core_kernel__.Map`
`module Memo = Core_kernel__.Memo`
`module Month = Core_kernel__.Month`
`module Moption = Core_kernel__.Moption`
`module No_polymorphic_compare = Core_kernel__.No_polymorphic_compare`
`module Nothing = Core_kernel__.Nothing`
`module Only_in_test = Core_kernel__.Only_in_test`
`module Option_array = Core_kernel__.Option_array`
`module Optional_syntax = Core_kernel__.Optional_syntax`
`module Percent = Core_kernel__.Percent`
`module Pid = Core_kernel__.Pid`
`module Pool = Core_kernel__.Pool`
`module Pool_intf = Core_kernel__.Pool_intf`
`module Pooled_hashtbl = Core_kernel__.Pooled_hashtbl`
`module Printexc = Core_kernel__.Printexc`
`module Queue = Core_kernel__.Queue`
`module Quickcheck = Core_kernel__.Quickcheck`
`module Quickcheck_intf = Core_kernel__.Quickcheck_intf`
`module Quickcheckable = Core_kernel__.Quickcheckable`
`module Robustly_comparable = Core_kernel__.Robustly_comparable`
`module Rope = Core_kernel__.Rope`
`module Set_once = Core_kernel__.Set_once`
`module Splittable_random = Splittable_random`
`module Stable_comparable = Core_kernel__.Stable_comparable`
`module Stable_unit_test = Core_kernel__.Stable_unit_test`
`module Stack = Core_kernel__.Stack`
`module String_id = Core_kernel__.String_id`
`module Substring = Core_kernel__.Substring`
`module Substring_intf = Core_kernel__.Substring_intf`
`module Thread_safe_queue = Core_kernel__.Thread_safe_queue`
`module Timing_wheel_ns = Core_kernel__.Timing_wheel_ns`
`module Total_map = Core_kernel__.Total_map`
`module Tuple = Core_kernel__.Tuple`
`module Tuple_type = Core_kernel__.Tuple_type`
`module Tuple2 = Tuple.T2`
`module Tuple3 = Tuple.T3`
`module Type_immediacy = Core_kernel__.Type_immediacy`
`module Uniform_array = Core_kernel__.Uniform_array`
`module Union_find = Core_kernel__.Union_find`
`module Unique_id = Core_kernel__.Unique_id`
`module Unit_of_time = Core_kernel__.Unit_of_time`
`module Univ = Core_kernel__.Univ`
`module Univ_map = Core_kernel__.Univ_map`
`module Unpack_buffer = Core_kernel__.Unpack_buffer`
`module Validated = Core_kernel__.Validated`
`module Weak = Core_kernel__.Weak`
`module Weak_pointer = Core_kernel__.Weak_pointer`
`module type Unique_id = Unique_id.Id`
`module type T : sig ... end`
`module type T1 : sig ... end`
`module type T2 : sig ... end`
`module type T3 : sig ... end`
`module type T_bin : sig ... end`
`type 'a _maybe_bound``= 'a Maybe_bound.t``=`

`|` `Incl of 'a`
`|` `Excl of 'a`
`|` `Unbounded`

``
`val does_raise : (unit ‑> 'a) ‑> bool`
`type bytes` = `[`

`|` ``This_type_does_not_equal_string_because_we_want_type_errors_to_say_string`

`]```
`val am_running_inline_test : bool`
`external raise : exn ‑> 'a = "%reraise"`
`external raise_notrace : exn ‑> 'a = "%raise_notrace"`
`val invalid_arg : string ‑> 'a`
`val failwith : string ‑> 'a`
`exception` `Exit`
`external (=) : 'a ‑> 'a ‑> bool = "%equal"`
`external (<>) : 'a ‑> 'a ‑> bool = "%notequal"`
`external (<) : 'a ‑> 'a ‑> bool = "%lessthan"`
`external (>) : 'a ‑> 'a ‑> bool = "%greaterthan"`
`external (<=) : 'a ‑> 'a ‑> bool = "%lessequal"`
`external (>=) : 'a ‑> 'a ‑> bool = "%greaterequal"`
`external compare : 'a ‑> 'a ‑> int = "%compare"`
`val min : 'a ‑> 'a ‑> 'a`
`val max : 'a ‑> 'a ‑> 'a`
`external (==) : 'a ‑> 'a ‑> bool = "%eq"`

- Deprecated [since 2014-10] Use [phys_equal]

`external (!=) : 'a ‑> 'a ‑> bool = "%noteq"`

- Deprecated [since 2014-10] Use [phys_equal]

`external not : bool ‑> bool = "%boolnot"`
`external (&&) : bool ‑> bool ‑> bool = "%sequand"`
`external (&) : bool ‑> bool ‑> bool = "%sequand"`

- Deprecated [since 2010-01] {!Pervasives.( && )} should be used instead.

`external (||) : bool ‑> bool ‑> bool = "%sequor"`
`external or : bool ‑> bool ‑> bool = "%sequor"`

- Deprecated [since 2010-01] {!Pervasives.( || )} should be used instead.

`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__ : 'a ‑> string * 'a = "%loc_LOC"`
`external __LINE_OF__ : 'a ‑> int * 'a = "%loc_LINE"`
`external __POS_OF__ : 'a ‑> (string * int * int * int) * 'a = "%loc_POS"`
`external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b = "%revapply"`
`external (@@) : ('a ‑> 'b) ‑> 'a ‑> '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`

- Deprecated [since 2014-10] Use [Int.max_value]

`val min_int : int`

- Deprecated [since 2014-10] Use [Int.min_value]

`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"`
`external sqrt : float ‑> float = "caml_sqrt_float" "sqrt"`
`external exp : float ‑> float = "caml_exp_float" "exp"`
`external log : float ‑> float = "caml_log_float" "log"`
`external log10 : float ‑> float = "caml_log10_float" "log10"`

- Deprecated [since 2016-07] Use [Float.log10]

`external expm1 : float ‑> float = "caml_expm1_float" "caml_expm1"`

- Deprecated [since 2016-07] Use [Float.expm1]

`external log1p : float ‑> float = "caml_log1p_float" "caml_log1p"`

- Deprecated [since 2016-07] Use [Float.log1p]

`external cos : float ‑> float = "caml_cos_float" "cos"`

- Deprecated [since 2016-07] Use [Float.cos]

`external sin : float ‑> float = "caml_sin_float" "sin"`

- Deprecated [since 2016-07] Use [Float.sin]

`external tan : float ‑> float = "caml_tan_float" "tan"`

- Deprecated [since 2016-07] Use [Float.tan]

`external acos : float ‑> float = "caml_acos_float" "acos"`

- Deprecated [since 2016-07] Use [Float.acos]

`external asin : float ‑> float = "caml_asin_float" "asin"`

- Deprecated [since 2016-07] Use [Float.asin]

`external atan : float ‑> float = "caml_atan_float" "atan"`

- Deprecated [since 2016-07] Use [Float.atan]

`external atan2 : float ‑> float ‑> float = "caml_atan2_float" "atan2"`

- Deprecated [since 2016-07] Use [Float.atan2]

`external hypot : float ‑> float ‑> float = "caml_hypot_float" "caml_hypot"`

- Deprecated [since 2016-07] Use [Float.hypot]

`external cosh : float ‑> float = "caml_cosh_float" "cosh"`

- Deprecated [since 2016-07] Use [Float.cosh]

`external sinh : float ‑> float = "caml_sinh_float" "sinh"`

- Deprecated [since 2016-07] Use [Float.sinh]

`external tanh : float ‑> float = "caml_tanh_float" "tanh"`

- Deprecated [since 2016-07] Use [Float.tanh]

`external ceil : float ‑> float = "caml_ceil_float" "ceil"`

- Deprecated [since 2014-10] Use [Float.round_up]

`external floor : float ‑> float = "caml_floor_float" "floor"`

- Deprecated [since 2014-10] Use [Float.round_down]

`external abs_float : float ‑> float = "%absfloat"`

- Deprecated [since 2014-10] Use [Float.abs]

`external copysign : float ‑> float ‑> float = "caml_copysign_float" "caml_copysign"`

- Deprecated [since 2016-07] Use [Float.copysign]

`external mod_float : float ‑> float ‑> float = "caml_fmod_float" "fmod"`

- Deprecated [since 2014-10] Use [Float.mod_float]

`external frexp : float ‑> float * int = "caml_frexp_float"`

- Deprecated [since 2014-10] Use [Float.frexp]

`external ldexp : float ‑> int ‑> float = "caml_ldexp_float" "caml_ldexp_float_unboxed"`

- Deprecated [since 2014-10] Use [Float.ldexp]

`external modf : float ‑> float * float = "caml_modf_float"`

- Deprecated [since 2014-10] Use [Float.modf]

`external float : int ‑> float = "%floatofint"`
`external float_of_int : int ‑> float = "%floatofint"`
`external truncate : float ‑> int = "%intoffloat"`

- Deprecated [since 2014-10] Use [Float.iround_towards_zero_exn]

`external int_of_float : float ‑> int = "%intoffloat"`
`val infinity : float`

- Deprecated [since 2014-10] Use [Float.infinity]

`val neg_infinity : float`

- Deprecated [since 2014-10] Use [Float.neg_infinity]

`val nan : float`

- Deprecated [since 2014-10] Use [Float.nan]

`val max_float : float`

- Deprecated [since 2014-10] Use [Float.max_value]

`val min_float : float`

- Deprecated [since 2014-10] Use [Float.min_value]

`val epsilon_float : float`

- Deprecated [since 2014-10] Use [Float.epsilon_float]

`type fpclass``= Pervasives.fpclass``=`

`|` `FP_normal`
`|` `FP_subnormal`
`|` `FP_zero`
`|` `FP_infinite`
`|` `FP_nan`

``
`external classify_float : float ‑> fpclass = "caml_classify_float" "caml_classify_float_unboxed"`

- Deprecated [since 2014-10] Use [Float.classify]

`val (^) : string ‑> string ‑> string`
`external int_of_char : char ‑> int = "%identity"`
`val char_of_int : int ‑> char`
`external ignore : 'a ‑> unit = "%ignore"`
`val string_of_bool : bool ‑> string`
`val bool_of_string : string ‑> bool`
`val string_of_int : int ‑> string`
`external int_of_string : string ‑> int = "caml_int_of_string"`
`val string_of_float : float ‑> string`
`external float_of_string : string ‑> float = "caml_float_of_string"`
`external fst : ('a * 'b) ‑> 'a = "%field0"`
`external snd : ('a * 'b) ‑> 'b = "%field1"`
`type in_channel``= Pervasives.in_channel```

- Deprecated [since 2016-04] Use [In_channel.t]

`type out_channel``= Pervasives.out_channel```

- Deprecated [since 2016-04] Use [Out_channel.t]

`val stdin : Pervasives.in_channel`

- Deprecated [since 2016-04] Use [In_channel.stdin]

`val stdout : Pervasives.out_channel`
`val stderr : Pervasives.out_channel`
`val print_char : char ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_char stdout]

`val print_string : string ‑> unit`
`val print_bytes : bytes ‑> unit`

- Deprecated [since 2016-04] Core doesn't support [bytes] yet.

`val print_int : int ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_string stdout]

`val print_float : float ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_string stdout]

`val print_endline : string ‑> unit`
`val print_newline : unit ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.newline stdout]

`val prerr_char : char ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_char stderr]

`val prerr_string : string ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_string stderr]

`val prerr_bytes : bytes ‑> unit`

- Deprecated [since 2016-04] Core doesn't support [bytes] yet

`val prerr_int : int ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_string stderr]

`val prerr_float : float ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_string stderr]

`val prerr_endline : string ‑> unit`
`val prerr_newline : unit ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.newline stderr]

`val read_line : unit ‑> string`

- Deprecated [since 2016-04] Use [Out_channel.(flush stdout); In_channel.(input_line_exn stdin)]

`val read_int : unit ‑> int`

- Deprecated [since 2016-04] Use [Out_channel.(flush stdout); Int.of_string In_channel.(input_line_exn stdin)]

`val read_float : unit ‑> float`

- Deprecated [since 2016-04] Use [Out_channel.(flush stdout); Float.of_string In_channel.(input_line_exn stdin)]

`type open_flag``= Pervasives.open_flag``=`

`|` `Open_rdonly`
`|` `Open_wronly`
`|` `Open_append`
`|` `Open_creat`
`|` `Open_trunc`
`|` `Open_excl`
`|` `Open_binary`
`|` `Open_text`
`|` `Open_nonblock`

``

- Deprecated [since 2016-04] Use [In_channel.create] and [Out_channel.create]

`val open_out : string ‑> Pervasives.out_channel`

- Deprecated [since 2016-04] Use [Out_channel.create]

`val open_out_bin : string ‑> Pervasives.out_channel`

- Deprecated [since 2016-04] Use [Out_channel.create]

`val open_out_gen : Pervasives.open_flag list ‑> int ‑> string ‑> Pervasives.out_channel`

- Deprecated [since 2016-04] Use [Out_channel.create]

`val flush : Pervasives.out_channel ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.flush]

`val flush_all : unit ‑> unit`

- Deprecated [since 2016-04]

`val output_char : Pervasives.out_channel ‑> char ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_char]

`val output_string : Pervasives.out_channel ‑> string ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_string]

`val output_bytes : Pervasives.out_channel ‑> bytes ‑> unit`

- Deprecated [since 2016-04] Core doesn't yet support bytes.

`val output : Pervasives.out_channel ‑> bytes ‑> int ‑> int ‑> unit`

- Deprecated [since 2016-04] Core doesn't yet support bytes.

`val output_substring : Pervasives.out_channel ‑> string ‑> int ‑> int ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output]

`val output_byte : Pervasives.out_channel ‑> int ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_byte]

`val output_binary_int : Pervasives.out_channel ‑> int ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_binary_int]

`val output_value : Pervasives.out_channel ‑> 'a ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.output_value]

`val seek_out : Pervasives.out_channel ‑> int ‑> unit`

- Deprecated [since 2014-10] Use [Out_channel.seek]

`val pos_out : Pervasives.out_channel ‑> int`

- Deprecated [since 2014-10] Use [Out_channel.pos]

`val out_channel_length : Pervasives.out_channel ‑> int`

- Deprecated [since 2014-10] Use [Out_channel.length]

`val close_out : Pervasives.out_channel ‑> unit`

- Deprecated [since 2014-10] Use [Out_channel.close]

`val close_out_noerr : Pervasives.out_channel ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.close] and catch exceptions

`val set_binary_mode_out : Pervasives.out_channel ‑> bool ‑> unit`

- Deprecated [since 2016-04] Use [Out_channel.set_binary_mode]

`val open_in : string ‑> Pervasives.in_channel`

- Deprecated [since 2016-04] Use [In_channel.create]

`val open_in_bin : string ‑> Pervasives.in_channel`

- Deprecated [since 2016-04] Use [In_channel.create]

`val open_in_gen : Pervasives.open_flag list ‑> int ‑> string ‑> Pervasives.in_channel`

- Deprecated [since 2016-04] Use [In_channel.create]

`val input_char : Pervasives.in_channel ‑> char`

- Deprecated [since 2016-04] Use [In_channel.input_char]

`val input_line : Pervasives.in_channel ‑> string`

- Deprecated [since 2016-04] Use [In_channel.input_line]

`val input : Pervasives.in_channel ‑> bytes ‑> int ‑> int ‑> int`

- Deprecated [since 2016-04] Core doesn't yet support bytes.

`val really_input : Pervasives.in_channel ‑> bytes ‑> int ‑> int ‑> unit`

- Deprecated [since 2016-04] Core doesn't yet support bytes.

`val really_input_string : Pervasives.in_channel ‑> int ‑> string`

- Deprecated [since 2016-04] Use [In_channel.really_input_exn ~pos:0]

`val input_byte : Pervasives.in_channel ‑> int`

- Deprecated [since 2016-04] Use [In_channel.input_byte]

`val input_binary_int : Pervasives.in_channel ‑> int`

- Deprecated [since 2016-04] Use [In_channel.input_binary_int]

`val input_value : Pervasives.in_channel ‑> 'a`

- Deprecated [since 2016-04] Use [In_channel.unsafe_input_value]

`val seek_in : Pervasives.in_channel ‑> int ‑> unit`

- Deprecated [since 2014-10] Use [In_channel.seek]

`val pos_in : Pervasives.in_channel ‑> int`

- Deprecated [since 2014-10] Use [In_channel.pos]

`val in_channel_length : Pervasives.in_channel ‑> int`

- Deprecated [since 2014-10] Use [In_channel.length]

`val close_in : Pervasives.in_channel ‑> unit`

- Deprecated [since 2014-10] Use [In_channel.close]

`val close_in_noerr : Pervasives.in_channel ‑> unit`

- Deprecated [since 2016-04] Use [In_channel.close] and catch exceptions

`val set_binary_mode_in : Pervasives.in_channel ‑> bool ‑> unit`

- Deprecated [since 2016-04] Use [In_channel.set_binary_mode]

`module LargeFile = Core_kernel__Core_pervasives.LargeFile`
`type 'a ref``= 'a Pervasives.ref``=` `{`

`mutable contents : 'a;`

`}```
`external ref : 'a ‑> 'a ref = "%makemutable"`
`external (!) : 'a ref ‑> 'a = "%field0"`
`external (:=) : 'a ref ‑> 'a ‑> unit = "%setfield0"`
`external incr : int ref ‑> unit = "%incr"`
`external decr : int ref ‑> unit = "%decr"`
`type ('a, 'b) result``= ('a, 'b) Pervasives.result``=`

`|` `Ok of 'a`
`|` `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`
`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`

- Deprecated [since 2015-11] Do not use.

`val unsafe_really_input : Pervasives.in_channel ‑> bytes ‑> int ‑> int ‑> unit`

- Deprecated [since 2015-11] Do not use.

`val do_at_exit : unit ‑> unit`

- Deprecated [since 2015-11] Do not use.

`val (|!) : 'a ‑> ('a ‑> 'b) ‑> 'b`

- Deprecated [since 2016-07] Use [ |> ]

`type ('f, 's) _either``= ('f, 's) Base__Either.t``=`

`|` `First of 'f`
`|` `Second of 's`

``
`val (>=.) : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> bool`
`val (<=.) : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> bool`
`val (=.) : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> bool`
`val (>.) : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> bool`
`val (<.) : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> bool`
`val (<>.) : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> bool`
`val robustly_compare : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> int`
`type bigstring``= Sexplib.Conv.bigstring```
`val bigstring_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> bigstring`
`val sexp_of_bigstring : bigstring ‑> Ppx_sexp_conv_lib.Sexp.t`
`type mat``= Sexplib.Conv.mat```
`val mat_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> mat`
`val sexp_of_mat : mat ‑> Ppx_sexp_conv_lib.Sexp.t`
`type vec``= Sexplib.Conv.vec```
`val vec_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> vec`
`val sexp_of_vec : vec ‑> Ppx_sexp_conv_lib.Sexp.t`
`val sexp_of_opaque : 'a ‑> Base.Sexp.t`
`val opaque_of_sexp : Base.Sexp.t ‑> 'a`
`val sexp_of_pair : ('a ‑> Base.Sexp.t) ‑> ('b ‑> Base.Sexp.t) ‑> ('a * 'b) ‑> Base.Sexp.t`
`val pair_of_sexp : (Base.Sexp.t ‑> 'a) ‑> (Base.Sexp.t ‑> 'b) ‑> Base.Sexp.t ‑> 'a * 'b`
`exception` `Of_sexp_error of Core_kernel__Import.exn * Base.Sexp.t`
`val of_sexp_error : Core_kernel__Import.string ‑> Base.Sexp.t ‑> 'a`
`val of_sexp_error_exn : Core_kernel__Import.exn ‑> Base.Sexp.t ‑> 'a`
`module type Applicative = Core_kernel__.Import.Applicative.S`
`module type Binable = Core_kernel__.Binable0.S`
`module type Comparable = Core_kernel__.Comparable.S`
`module type Comparable_binable = Core_kernel__.Comparable.S_binable`
`module type Floatable = Core_kernel__.Import.Floatable.S`
`module type Hashable = Core_kernel__.Hashable.S`
`module type Hashable_binable = Core_kernel__.Hashable.S_binable`
`module type Identifiable = Core_kernel__.Identifiable.S`
`module type Infix_comparators = Core_kernel__.Comparable.Infix`
`module type Intable = Core_kernel__.Import.Intable.S`
`module type Monad = Core_kernel__.Import.Monad.S`
`module type Quickcheckable = Core_kernel__.Quickcheckable.S`
`module type Robustly_comparable = Core_kernel__.Robustly_comparable.S`
`module type Sexpable = Core_kernel__.Sexpable.S`
`module type Stable = Core_kernel__.Stable_module_types.S0`
`module type Stable_int63able = Core_kernel__.Stable_int63able.S`
`module type Stable_without_comparator = Core_kernel__.Stable_module_types.S0_without_comparator`
`module type Stable1 = Core_kernel__.Stable_module_types.S1`
`module type Stable2 = Core_kernel__.Stable_module_types.S2`
`module type Stable3 = Core_kernel__.Stable_module_types.S3`
`module type Stable4 = Core_kernel__.Stable_module_types.S4`
`module type Stringable = Core_kernel__.Import.Stringable.S`
`module type Unit = Core_kernel__.Unit.S`
`val (@) : 'a Base__List.t ‑> 'a Base__List.t ‑> 'a Base__List.t`
`type never_returns``= Core_kernel__.Nothing.t```
`val sexp_of_never_returns : never_returns ‑> Ppx_sexp_conv_lib.Sexp.t`
`val never_returns : Core_kernel__.Nothing.t ‑> 'a`
`type _ordering``= Base__Ordering.t``=`

`|` `Less`
`|` `Equal`
`|` `Greater`

``
`type read``= Core_kernel__Perms.Read.t```
`val bin_read : read Bin_prot.Type_class.t`
`val bin_read_read : read Bin_prot.Read.reader`
`val __bin_read_read__ : (Core_kernel__.Import.int ‑> read) Bin_prot.Read.reader`
`val bin_reader_read : read Bin_prot.Type_class.reader`
`val bin_size_read : read Bin_prot.Size.sizer`
`val bin_write_read : read Bin_prot.Write.writer`
`val bin_writer_read : read Bin_prot.Type_class.writer`
`val bin_shape_read : Bin_prot.Shape.t`
`val compare_read : read ‑> read ‑> Core_kernel__.Import.int`
`val hash_fold_read : Ppx_hash_lib.Std.Hash.state ‑> read ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_read : read ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val read_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> read`
`val sexp_of_read : read ‑> Ppx_sexp_conv_lib.Sexp.t`
`type write``= Core_kernel__Perms.Write.t```
`val compare_write : write ‑> write ‑> Core_kernel__.Import.int`
`val hash_fold_write : Ppx_hash_lib.Std.Hash.state ‑> write ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_write : write ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val write_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> write`
`val sexp_of_write : write ‑> Ppx_sexp_conv_lib.Sexp.t`
`type immutable``= Core_kernel__Perms.Immutable.t```
`val bin_immutable : immutable Bin_prot.Type_class.t`
`val bin_read_immutable : immutable Bin_prot.Read.reader`
`val __bin_read_immutable__ : (Core_kernel__.Import.int ‑> immutable) Bin_prot.Read.reader`
`val bin_reader_immutable : immutable Bin_prot.Type_class.reader`
`val bin_size_immutable : immutable Bin_prot.Size.sizer`
`val bin_write_immutable : immutable Bin_prot.Write.writer`
`val bin_writer_immutable : immutable Bin_prot.Type_class.writer`
`val bin_shape_immutable : Bin_prot.Shape.t`
`val compare_immutable : immutable ‑> immutable ‑> Core_kernel__.Import.int`
`val hash_fold_immutable : Ppx_hash_lib.Std.Hash.state ‑> immutable ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_immutable : immutable ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val immutable_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> immutable`
`val sexp_of_immutable : immutable ‑> Ppx_sexp_conv_lib.Sexp.t`
`type read_write``= Core_kernel__Perms.Read_write.t```
`val bin_read_write : read_write Bin_prot.Type_class.t`
`val bin_read_read_write : read_write Bin_prot.Read.reader`
`val __bin_read_read_write__ : (Core_kernel__.Import.int ‑> read_write) Bin_prot.Read.reader`
`val bin_reader_read_write : read_write Bin_prot.Type_class.reader`
`val bin_size_read_write : read_write Bin_prot.Size.sizer`
`val bin_write_read_write : read_write Bin_prot.Write.writer`
`val bin_writer_read_write : read_write Bin_prot.Type_class.writer`
`val bin_shape_read_write : Bin_prot.Shape.t`
`val compare_read_write : read_write ‑> read_write ‑> Core_kernel__.Import.int`
`val hash_fold_read_write : Ppx_hash_lib.Std.Hash.state ‑> read_write ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_read_write : read_write ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val read_write_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> read_write`
`val sexp_of_read_write : read_write ‑> Ppx_sexp_conv_lib.Sexp.t`
`type 'a perms``= 'a Core_kernel__Perms.Upper_bound.t```
`val bin_perms : 'a Bin_prot.Type_class.t ‑> 'a perms Bin_prot.Type_class.t`
`val bin_read_perms : 'a Bin_prot.Read.reader ‑> 'a perms Bin_prot.Read.reader`
`val __bin_read_perms__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a perms) Bin_prot.Read.reader`
`val bin_reader_perms : 'a Bin_prot.Type_class.reader ‑> 'a perms Bin_prot.Type_class.reader`
`val bin_size_perms : 'a Bin_prot.Size.sizer ‑> 'a perms Bin_prot.Size.sizer`
`val bin_write_perms : 'a Bin_prot.Write.writer ‑> 'a perms Bin_prot.Write.writer`
`val bin_writer_perms : 'a Bin_prot.Type_class.writer ‑> 'a perms Bin_prot.Type_class.writer`
`val bin_shape_perms : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val compare_perms : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a perms ‑> 'a perms ‑> Core_kernel__.Import.int`
`val hash_fold_perms : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a perms ‑> Ppx_hash_lib.Std.Hash.state`
`val perms_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a perms`
`val sexp_of_perms : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a perms ‑> Ppx_sexp_conv_lib.Sexp.t`
`type ('ok, 'err) _result``= ('ok, 'err) Base__Result.t``=`

`|` `Ok of 'ok`
`|` `Error of 'err`

``
`val is_ok : ('a, 'b) Base__Result.t ‑> bool`
`val is_error : ('a, 'b) Base__Result.t ‑> bool`
`type -'a return``= private 'a Core_kernel__.Import.With_return.return``=` `{`

`return : b. 'a ‑> 'b;`

`}```
`exception` `Bug of Core_kernel__.Import.string`
`exception` `C_malloc_exn of Core_kernel__.Import.int * Core_kernel__.Import.int`
`exception` `Finally of Core_kernel__.Import.Exn.t * Core_kernel__.Import.Exn.t`
`val fst3 : ('a * 'b * 'c) ‑> 'a`
`val snd3 : ('a * 'b * 'c) ‑> 'b`
`val trd3 : ('a * 'b * 'c) ‑> 'c`
`val uw : 'a option ‑> 'a`
`val (%) : Core_kernel__.Int.t ‑> Core_kernel__.Int.t ‑> Core_kernel__.Int.t`
`val (/%) : Core_kernel__.Int.t ‑> Core_kernel__.Int.t ‑> Core_kernel__.Int.t`
`val (//) : Core_kernel__.Int.t ‑> Core_kernel__.Int.t ‑> float`
`val (==>) : bool ‑> bool ‑> bool`
`val print_s : ?⁠mach:unit ‑> Core_kernel__.Sexp.t ‑> unit`
`val bprintf : Base__.Import0.Caml.Buffer.t ‑> ('a, Base__.Import0.Caml.Buffer.t, unit) Pervasives.format ‑> 'a`
`val const : 'a ‑> 'b ‑> 'a`
`val eprintf : ('a, Stdio.Out_channel.t, Base.unit) Base.format ‑> 'a`
`val error : ?⁠strict:unit ‑> string ‑> 'a ‑> ('a ‑> Base__.Sexp.t) ‑> 'b Core_kernel__.Or_error.t`
`val error_s : Base__.Sexp.t ‑> 'a Core_kernel__.Or_error.t`
`val failwithf : ('a, unit, string, unit ‑> 'b) Pervasives.format4 ‑> 'a`
`val failwithp : ?⁠strict:Core_kernel__.Import.unit ‑> Lexing.position ‑> Core_kernel__.Import.string ‑> 'a ‑> ('a ‑> Base.Sexp.t) ‑> 'b`
`val failwiths : ?⁠strict:Core_kernel__.Import.unit ‑> ?⁠here:Lexing.position ‑> Core_kernel__.Import.string ‑> 'a ‑> ('a ‑> Base.Sexp.t) ‑> 'b`
`val force : 'a Base.Lazy.t ‑> 'a`
`val fprintf : Stdio.Out_channel.t ‑> ('a, Stdio.Out_channel.t, Base.unit) Base.format ‑> 'a`
`val ident : 'a ‑> 'a`
`val invalid_argf : ('a, unit, string, unit ‑> 'b) Pervasives.format4 ‑> 'a`
`val ifprintf : 'a ‑> ('b, 'a, 'c, unit) Pervasives.format4 ‑> 'b`
`val is_none : 'a Core_kernel__.Option.t ‑> bool`
`val is_some : 'a Core_kernel__.Option.t ‑> bool`
`val ksprintf : (string ‑> 'a) ‑> ('b, unit, string, 'a) Pervasives.format4 ‑> 'b`
`val ok_exn : 'a Core_kernel__.Or_error.t ‑> 'a`
`val phys_equal : 'a ‑> 'a ‑> bool`
`val phys_same : 'a ‑> 'b ‑> bool`
`val printf : ('a, Stdio.Out_channel.t, Base.unit) Base.format ‑> 'a`
`val protect : f:(unit ‑> 'a) ‑> finally:(unit ‑> unit) ‑> 'a`
`val protectx : f:('a ‑> 'b) ‑> 'a ‑> finally:('a ‑> unit) ‑> 'b`
`val raise_s : Base__.Sexp.t ‑> 'a`
`val round : ?⁠dir:[ `Down | `Nearest | `Up | `Zero ] ‑> Core_kernel__.Float.t ‑> Core_kernel__.Float.t`
`val sprintf : ('a, unit, string) Pervasives.format ‑> 'a`
`val stage : 'a ‑> 'a Core_kernel__.Import.Staged.t`
`val unstage : 'a Core_kernel__.Import.Staged.t ‑> 'a`
`val with_return : ('a Core_kernel__.Import.With_return.return ‑> 'a) ‑> 'a`
`val with_return_option : ('a Core_kernel__.Import.With_return.return ‑> unit) ‑> 'a option`
`module Typerep = Typerep_lib__Std_internal.Typerep`
`type tuple0``= Typerep_lib__Std_internal.tuple0```
`val value_tuple0 : tuple0`
`val typerep_of_function : 'a Typerep.t ‑> 'b Typerep.t ‑> ('a ‑> 'b) Typerep.t`
`val typerep_of_tuple0 : tuple0 Typerep.t`
`val typerep_of_tuple2 : 'a Typerep.t ‑> 'b Typerep.t ‑> ('a * 'b) Typerep.t`
`val typerep_of_tuple3 : 'a Typerep.t ‑> 'b Typerep.t ‑> 'c Typerep.t ‑> ('a * 'b * 'c) Typerep.t`
`val typerep_of_tuple4 : 'a Typerep.t ‑> 'b Typerep.t ‑> 'c Typerep.t ‑> 'd Typerep.t ‑> ('a * 'b * 'c * 'd) Typerep.t`
`val typerep_of_tuple5 : 'a Typerep.t ‑> 'b Typerep.t ‑> 'c Typerep.t ‑> 'd Typerep.t ‑> 'e Typerep.t ‑> ('a * 'b * 'c * 'd * 'e) Typerep.t`
`val typename_of_function : 'a Typerep_lib.Typename.t ‑> 'b Typerep_lib.Typename.t ‑> ('a ‑> 'b) Typerep_lib.Typename.t`
`val typename_of_tuple0 : tuple0 Typerep_lib.Typename.t`
`val typename_of_tuple2 : 'a Typerep_lib.Typename.t ‑> 'b Typerep_lib.Typename.t ‑> ('a * 'b) Typerep_lib.Typename.t`
`val typename_of_tuple3 : 'a Typerep_lib.Typename.t ‑> 'b Typerep_lib.Typename.t ‑> 'c Typerep_lib.Typename.t ‑> ('a * 'b * 'c) Typerep_lib.Typename.t`
`val typename_of_tuple4 : 'a Typerep_lib.Typename.t ‑> 'b Typerep_lib.Typename.t ‑> 'c Typerep_lib.Typename.t ‑> 'd Typerep_lib.Typename.t ‑> ('a * 'b * 'c * 'd) Typerep_lib.Typename.t`
`val typename_of_tuple5 : 'a Typerep_lib.Typename.t ‑> 'b Typerep_lib.Typename.t ‑> 'c Typerep_lib.Typename.t ‑> 'd Typerep_lib.Typename.t ‑> 'e Typerep_lib.Typename.t ‑> ('a * 'b * 'c * 'd * 'e) Typerep_lib.Typename.t`
`val bin_array : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.t`
`val bin_read_array : 'a Bin_prot.Read.reader ‑> 'a Core_kernel__.Import.array Bin_prot.Read.reader`
`val __bin_read_array__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.array) Bin_prot.Read.reader`
`val bin_reader_array : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.reader`
`val bin_size_array : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.array Bin_prot.Size.sizer`
`val bin_write_array : 'a Bin_prot.Write.writer ‑> 'a Core_kernel__.Import.array Bin_prot.Write.writer`
`val bin_writer_array : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.writer`
`val bin_shape_array : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val compare_array : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a Core_kernel__.Import.array ‑> 'a Core_kernel__.Import.array ‑> Core_kernel__.Import.int`
`val array_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a Core_kernel__.Import.array`
`val sexp_of_array : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a Core_kernel__.Import.array ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_array : 'a Typerep_lib.Std.Typerep.t ‑> 'a Core_kernel__.Import.array Typerep_lib.Std.Typerep.t`
`val typename_of_array : 'a Typerep_lib.Std.Typename.t ‑> 'a Core_kernel__.Import.array Typerep_lib.Std.Typename.t`
`val bin_bool : Core_kernel__.Import.bool Bin_prot.Type_class.t`
`val bin_read_bool : Core_kernel__.Import.bool Bin_prot.Read.reader`
`val __bin_read_bool__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.bool) Bin_prot.Read.reader`
`val bin_reader_bool : Core_kernel__.Import.bool Bin_prot.Type_class.reader`
`val bin_size_bool : Core_kernel__.Import.bool Bin_prot.Size.sizer`
`val bin_write_bool : Core_kernel__.Import.bool Bin_prot.Write.writer`
`val bin_writer_bool : Core_kernel__.Import.bool Bin_prot.Type_class.writer`
`val bin_shape_bool : Bin_prot.Shape.t`
`val compare_bool : Core_kernel__.Import.bool ‑> Core_kernel__.Import.bool ‑> Core_kernel__.Import.int`
`val hash_fold_bool : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.bool ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_bool : Core_kernel__.Import.bool ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val bool_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.bool`
`val sexp_of_bool : Core_kernel__.Import.bool ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_bool : Core_kernel__.Import.bool Typerep_lib.Std.Typerep.t`
`val typename_of_bool : Core_kernel__.Import.bool Typerep_lib.Std.Typename.t`
`val bin_char : Core_kernel__.Import.char Bin_prot.Type_class.t`
`val bin_read_char : Core_kernel__.Import.char Bin_prot.Read.reader`
`val __bin_read_char__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.char) Bin_prot.Read.reader`
`val bin_reader_char : Core_kernel__.Import.char Bin_prot.Type_class.reader`
`val bin_size_char : Core_kernel__.Import.char Bin_prot.Size.sizer`
`val bin_write_char : Core_kernel__.Import.char Bin_prot.Write.writer`
`val bin_writer_char : Core_kernel__.Import.char Bin_prot.Type_class.writer`
`val bin_shape_char : Bin_prot.Shape.t`
`val compare_char : Core_kernel__.Import.char ‑> Core_kernel__.Import.char ‑> Core_kernel__.Import.int`
`val hash_fold_char : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.char ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_char : Core_kernel__.Import.char ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val char_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.char`
`val sexp_of_char : Core_kernel__.Import.char ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_char : Core_kernel__.Import.char Typerep_lib.Std.Typerep.t`
`val typename_of_char : Core_kernel__.Import.char Typerep_lib.Std.Typename.t`
`val bin_float : Core_kernel__.Import.float Bin_prot.Type_class.t`
`val bin_read_float : Core_kernel__.Import.float Bin_prot.Read.reader`
`val __bin_read_float__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.float) Bin_prot.Read.reader`
`val bin_reader_float : Core_kernel__.Import.float Bin_prot.Type_class.reader`
`val bin_size_float : Core_kernel__.Import.float Bin_prot.Size.sizer`
`val bin_write_float : Core_kernel__.Import.float Bin_prot.Write.writer`
`val bin_writer_float : Core_kernel__.Import.float Bin_prot.Type_class.writer`
`val bin_shape_float : Bin_prot.Shape.t`
`val compare_float : Core_kernel__.Import.float ‑> Core_kernel__.Import.float ‑> Core_kernel__.Import.int`
`val hash_fold_float : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.float ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_float : Core_kernel__.Import.float ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val float_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.float`
`val sexp_of_float : Core_kernel__.Import.float ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_float : Core_kernel__.Import.float Typerep_lib.Std.Typerep.t`
`val typename_of_float : Core_kernel__.Import.float Typerep_lib.Std.Typename.t`
`val bin_int : Core_kernel__.Import.int Bin_prot.Type_class.t`
`val bin_read_int : Core_kernel__.Import.int Bin_prot.Read.reader`
`val __bin_read_int__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.int) Bin_prot.Read.reader`
`val bin_reader_int : Core_kernel__.Import.int Bin_prot.Type_class.reader`
`val bin_size_int : Core_kernel__.Import.int Bin_prot.Size.sizer`
`val bin_write_int : Core_kernel__.Import.int Bin_prot.Write.writer`
`val bin_writer_int : Core_kernel__.Import.int Bin_prot.Type_class.writer`
`val bin_shape_int : Bin_prot.Shape.t`
`val compare_int : Core_kernel__.Import.int ‑> Core_kernel__.Import.int ‑> Core_kernel__.Import.int`
`val hash_fold_int : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.int ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_int : Core_kernel__.Import.int ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val int_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.int`
`val sexp_of_int : Core_kernel__.Import.int ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_int : Core_kernel__.Import.int Typerep_lib.Std.Typerep.t`
`val typename_of_int : Core_kernel__.Import.int Typerep_lib.Std.Typename.t`
`val bin_int32 : Core_kernel__.Import.int32 Bin_prot.Type_class.t`
`val bin_read_int32 : Core_kernel__.Import.int32 Bin_prot.Read.reader`
`val __bin_read_int32__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.int32) Bin_prot.Read.reader`
`val bin_reader_int32 : Core_kernel__.Import.int32 Bin_prot.Type_class.reader`
`val bin_size_int32 : Core_kernel__.Import.int32 Bin_prot.Size.sizer`
`val bin_write_int32 : Core_kernel__.Import.int32 Bin_prot.Write.writer`
`val bin_writer_int32 : Core_kernel__.Import.int32 Bin_prot.Type_class.writer`
`val bin_shape_int32 : Bin_prot.Shape.t`
`val compare_int32 : Core_kernel__.Import.int32 ‑> Core_kernel__.Import.int32 ‑> Core_kernel__.Import.int`
`val hash_fold_int32 : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.int32 ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_int32 : Core_kernel__.Import.int32 ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val int32_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.int32`
`val sexp_of_int32 : Core_kernel__.Import.int32 ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_int32 : Core_kernel__.Import.int32 Typerep_lib.Std.Typerep.t`
`val typename_of_int32 : Core_kernel__.Import.int32 Typerep_lib.Std.Typename.t`
`val bin_int64 : Core_kernel__.Import.int64 Bin_prot.Type_class.t`
`val bin_read_int64 : Core_kernel__.Import.int64 Bin_prot.Read.reader`
`val __bin_read_int64__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.int64) Bin_prot.Read.reader`
`val bin_reader_int64 : Core_kernel__.Import.int64 Bin_prot.Type_class.reader`
`val bin_size_int64 : Core_kernel__.Import.int64 Bin_prot.Size.sizer`
`val bin_write_int64 : Core_kernel__.Import.int64 Bin_prot.Write.writer`
`val bin_writer_int64 : Core_kernel__.Import.int64 Bin_prot.Type_class.writer`
`val bin_shape_int64 : Bin_prot.Shape.t`
`val compare_int64 : Core_kernel__.Import.int64 ‑> Core_kernel__.Import.int64 ‑> Core_kernel__.Import.int`
`val hash_fold_int64 : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.int64 ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_int64 : Core_kernel__.Import.int64 ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val int64_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.int64`
`val sexp_of_int64 : Core_kernel__.Import.int64 ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_int64 : Core_kernel__.Import.int64 Typerep_lib.Std.Typerep.t`
`val typename_of_int64 : Core_kernel__.Import.int64 Typerep_lib.Std.Typename.t`
`val bin_lazy_t : 'a Bin_prot.Type_class.t ‑> 'a lazy_t Bin_prot.Type_class.t`
`val bin_read_lazy_t : 'a Bin_prot.Read.reader ‑> 'a lazy_t Bin_prot.Read.reader`
`val __bin_read_lazy_t__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a lazy_t) Bin_prot.Read.reader`
`val bin_reader_lazy_t : 'a Bin_prot.Type_class.reader ‑> 'a lazy_t Bin_prot.Type_class.reader`
`val bin_size_lazy_t : 'a Bin_prot.Size.sizer ‑> 'a lazy_t Bin_prot.Size.sizer`
`val bin_write_lazy_t : 'a Bin_prot.Write.writer ‑> 'a lazy_t Bin_prot.Write.writer`
`val bin_writer_lazy_t : 'a Bin_prot.Type_class.writer ‑> 'a lazy_t Bin_prot.Type_class.writer`
`val bin_shape_lazy_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val compare_lazy_t : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a lazy_t ‑> 'a lazy_t ‑> Core_kernel__.Import.int`
`val hash_fold_lazy_t : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a lazy_t ‑> Ppx_hash_lib.Std.Hash.state`
`val lazy_t_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a lazy_t`
`val sexp_of_lazy_t : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a lazy_t ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_lazy_t : 'a Typerep_lib.Std.Typerep.t ‑> 'a lazy_t Typerep_lib.Std.Typerep.t`
`val typename_of_lazy_t : 'a Typerep_lib.Std.Typename.t ‑> 'a lazy_t Typerep_lib.Std.Typename.t`
`val bin_list : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.t`
`val bin_read_list : 'a Bin_prot.Read.reader ‑> 'a Core_kernel__.Import.list Bin_prot.Read.reader`
`val __bin_read_list__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.list) Bin_prot.Read.reader`
`val bin_reader_list : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.reader`
`val bin_size_list : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.list Bin_prot.Size.sizer`
`val bin_write_list : 'a Bin_prot.Write.writer ‑> 'a Core_kernel__.Import.list Bin_prot.Write.writer`
`val bin_writer_list : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.writer`
`val bin_shape_list : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val compare_list : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a Core_kernel__.Import.list ‑> 'a Core_kernel__.Import.list ‑> Core_kernel__.Import.int`
`val hash_fold_list : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a Core_kernel__.Import.list ‑> Ppx_hash_lib.Std.Hash.state`
`val list_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a Core_kernel__.Import.list`
`val sexp_of_list : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a Core_kernel__.Import.list ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_list : 'a Typerep_lib.Std.Typerep.t ‑> 'a Core_kernel__.Import.list Typerep_lib.Std.Typerep.t`
`val typename_of_list : 'a Typerep_lib.Std.Typename.t ‑> 'a Core_kernel__.Import.list Typerep_lib.Std.Typename.t`
`val bin_nativeint : Core_kernel__.Import.nativeint Bin_prot.Type_class.t`
`val bin_read_nativeint : Core_kernel__.Import.nativeint Bin_prot.Read.reader`
`val __bin_read_nativeint__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.nativeint) Bin_prot.Read.reader`
`val bin_reader_nativeint : Core_kernel__.Import.nativeint Bin_prot.Type_class.reader`
`val bin_size_nativeint : Core_kernel__.Import.nativeint Bin_prot.Size.sizer`
`val bin_write_nativeint : Core_kernel__.Import.nativeint Bin_prot.Write.writer`
`val bin_writer_nativeint : Core_kernel__.Import.nativeint Bin_prot.Type_class.writer`
`val bin_shape_nativeint : Bin_prot.Shape.t`
`val compare_nativeint : Core_kernel__.Import.nativeint ‑> Core_kernel__.Import.nativeint ‑> Core_kernel__.Import.int`
`val hash_fold_nativeint : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.nativeint ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_nativeint : Core_kernel__.Import.nativeint ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val nativeint_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.nativeint`
`val sexp_of_nativeint : Core_kernel__.Import.nativeint ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_nativeint : Core_kernel__.Import.nativeint Typerep_lib.Std.Typerep.t`
`val typename_of_nativeint : Core_kernel__.Import.nativeint Typerep_lib.Std.Typename.t`
`val bin_option : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.t`
`val bin_read_option : 'a Bin_prot.Read.reader ‑> 'a Core_kernel__.Import.option Bin_prot.Read.reader`
`val __bin_read_option__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.option) Bin_prot.Read.reader`
`val bin_reader_option : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.reader`
`val bin_size_option : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.option Bin_prot.Size.sizer`
`val bin_write_option : 'a Bin_prot.Write.writer ‑> 'a Core_kernel__.Import.option Bin_prot.Write.writer`
`val bin_writer_option : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.writer`
`val bin_shape_option : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val compare_option : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a Core_kernel__.Import.option ‑> 'a Core_kernel__.Import.option ‑> Core_kernel__.Import.int`
`val hash_fold_option : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a Core_kernel__.Import.option ‑> Ppx_hash_lib.Std.Hash.state`
`val option_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a Core_kernel__.Import.option`
`val sexp_of_option : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a Core_kernel__.Import.option ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_option : 'a Typerep_lib.Std.Typerep.t ‑> 'a Core_kernel__.Import.option Typerep_lib.Std.Typerep.t`
`val typename_of_option : 'a Typerep_lib.Std.Typename.t ‑> 'a Core_kernel__.Import.option Typerep_lib.Std.Typename.t`
`val bin_string : Core_kernel__.Import.string Bin_prot.Type_class.t`
`val bin_read_string : Core_kernel__.Import.string Bin_prot.Read.reader`
`val __bin_read_string__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.string) Bin_prot.Read.reader`
`val bin_reader_string : Core_kernel__.Import.string Bin_prot.Type_class.reader`
`val bin_size_string : Core_kernel__.Import.string Bin_prot.Size.sizer`
`val bin_write_string : Core_kernel__.Import.string Bin_prot.Write.writer`
`val bin_writer_string : Core_kernel__.Import.string Bin_prot.Type_class.writer`
`val bin_shape_string : Bin_prot.Shape.t`
`val compare_string : Core_kernel__.Import.string ‑> Core_kernel__.Import.string ‑> Core_kernel__.Import.int`
`val hash_fold_string : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.string ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_string : Core_kernel__.Import.string ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val string_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.string`
`val sexp_of_string : Core_kernel__.Import.string ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_string : Core_kernel__.Import.string Typerep_lib.Std.Typerep.t`
`val typename_of_string : Core_kernel__.Import.string Typerep_lib.Std.Typename.t`
`val bin_bytes : Core_kernel__.Import.bytes Bin_prot.Type_class.t`
`val bin_read_bytes : Core_kernel__.Import.bytes Bin_prot.Read.reader`
`val __bin_read_bytes__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.bytes) Bin_prot.Read.reader`
`val bin_reader_bytes : Core_kernel__.Import.bytes Bin_prot.Type_class.reader`
`val bin_size_bytes : Core_kernel__.Import.bytes Bin_prot.Size.sizer`
`val bin_write_bytes : Core_kernel__.Import.bytes Bin_prot.Write.writer`
`val bin_writer_bytes : Core_kernel__.Import.bytes Bin_prot.Type_class.writer`
`val bin_shape_bytes : Bin_prot.Shape.t`
`val compare_bytes : Core_kernel__.Import.bytes ‑> Core_kernel__.Import.bytes ‑> Core_kernel__.Import.int`
`val bytes_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.bytes`
`val sexp_of_bytes : Core_kernel__.Import.bytes ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_bytes : Core_kernel__.Import.bytes Typerep_lib.Std.Typerep.t`
`val typename_of_bytes : Core_kernel__.Import.bytes Typerep_lib.Std.Typename.t`
`val bin_ref : 'a Bin_prot.Type_class.t ‑> 'a ref Bin_prot.Type_class.t`
`val bin_read_ref : 'a Bin_prot.Read.reader ‑> 'a ref Bin_prot.Read.reader`
`val __bin_read_ref__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a ref) Bin_prot.Read.reader`
`val bin_reader_ref : 'a Bin_prot.Type_class.reader ‑> 'a ref Bin_prot.Type_class.reader`
`val bin_size_ref : 'a Bin_prot.Size.sizer ‑> 'a ref Bin_prot.Size.sizer`
`val bin_write_ref : 'a Bin_prot.Write.writer ‑> 'a ref Bin_prot.Write.writer`
`val bin_writer_ref : 'a Bin_prot.Type_class.writer ‑> 'a ref Bin_prot.Type_class.writer`
`val bin_shape_ref : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val compare_ref : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a ref ‑> 'a ref ‑> Core_kernel__.Import.int`
`val ref_of_sexp : (Ppx_sexp_conv_lib.Sexp.t ‑> 'a) ‑> Ppx_sexp_conv_lib.Sexp.t ‑> 'a ref`
`val sexp_of_ref : ('a ‑> Ppx_sexp_conv_lib.Sexp.t) ‑> 'a ref ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_ref : 'a Typerep_lib.Std.Typerep.t ‑> 'a ref Typerep_lib.Std.Typerep.t`
`val typename_of_ref : 'a Typerep_lib.Std.Typename.t ‑> 'a ref Typerep_lib.Std.Typename.t`
`val bin_unit : Core_kernel__.Import.unit Bin_prot.Type_class.t`
`val bin_read_unit : Core_kernel__.Import.unit Bin_prot.Read.reader`
`val __bin_read_unit__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.unit) Bin_prot.Read.reader`
`val bin_reader_unit : Core_kernel__.Import.unit Bin_prot.Type_class.reader`
`val bin_size_unit : Core_kernel__.Import.unit Bin_prot.Size.sizer`
`val bin_write_unit : Core_kernel__.Import.unit Bin_prot.Write.writer`
`val bin_writer_unit : Core_kernel__.Import.unit Bin_prot.Type_class.writer`
`val bin_shape_unit : Bin_prot.Shape.t`
`val compare_unit : Core_kernel__.Import.unit ‑> Core_kernel__.Import.unit ‑> Core_kernel__.Import.int`
`val hash_fold_unit : Ppx_hash_lib.Std.Hash.state ‑> Core_kernel__.Import.unit ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_unit : Core_kernel__.Import.unit ‑> Ppx_hash_lib.Std.Hash.hash_value`
`val unit_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> Core_kernel__.Import.unit`
`val sexp_of_unit : Core_kernel__.Import.unit ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_unit : Core_kernel__.Import.unit Typerep_lib.Std.Typerep.t`
`val typename_of_unit : Core_kernel__.Import.unit Typerep_lib.Std.Typename.t`
`type float_array``= Core_kernel__.Import.float Core_kernel__.Import.array```
`val bin_float_array : float_array Bin_prot.Type_class.t`
`val bin_read_float_array : float_array Bin_prot.Read.reader`
`val __bin_read_float_array__ : (Core_kernel__.Import.int ‑> float_array) Bin_prot.Read.reader`
`val bin_reader_float_array : float_array Bin_prot.Type_class.reader`
`val bin_size_float_array : float_array Bin_prot.Size.sizer`
`val bin_write_float_array : float_array Bin_prot.Write.writer`
`val bin_writer_float_array : float_array Bin_prot.Type_class.writer`
`val bin_shape_float_array : Bin_prot.Shape.t`
`val compare_float_array : float_array ‑> float_array ‑> Core_kernel__.Import.int`
`val float_array_of_sexp : Ppx_sexp_conv_lib.Sexp.t ‑> float_array`
`val sexp_of_float_array : float_array ‑> Ppx_sexp_conv_lib.Sexp.t`
`val typerep_of_float_array : float_array Typerep_lib.Std.Typerep.t`
`val typename_of_float_array : float_array Typerep_lib.Std.Typename.t`
`val sexp_of_exn : Core_kernel__.Import.Exn.t ‑> Base__.Ppx_sexp_conv_lib.Sexp.t`
`type 'a sexp_array``= 'a Core_kernel__.Import.array```
`val bin_shape_sexp_array : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val bin_size_sexp_array : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.array ‑> int`
`val bin_write_sexp_array : 'a Bin_prot.Write.writer ‑> Bin_prot.Common.buf ‑> pos:Bin_prot.Common.pos ‑> 'a Core_kernel__.Import.array ‑> Bin_prot.Common.pos`
`val bin_writer_sexp_array : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.writer`
`val __bin_read_sexp_array__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.array`
`val bin_read_sexp_array : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> 'a Core_kernel__.Import.array`
`val bin_reader_sexp_array : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.reader`
`val bin_sexp_array : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.array Bin_prot.Type_class.t`
`val compare_sexp_array : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a sexp_array ‑> 'a sexp_array ‑> Core_kernel__.Import.int`
`module Typename_of_sexp_array = Core_kernel__Std_internal.Typename_of_sexp_array`
`val typename_of_sexp_array : 'a Typerep_lib.Typename.t ‑> 'a sexp_array Typerep_lib.Typename.t`
`val typerep_of_sexp_array : 'a Typerep_lib.Std.Typerep.t ‑> 'a sexp_array Typerep_lib.Std.Typerep.t`
`type sexp_bool``= Core_kernel__.Import.bool```
`val bin_shape_sexp_bool : Bin_prot.Shape.t`
`val bin_size_sexp_bool : Core_kernel__.Import.bool Bin_prot.Size.sizer`
`val bin_write_sexp_bool : Core_kernel__.Import.bool Bin_prot.Write.writer`
`val bin_writer_sexp_bool : Core_kernel__.Import.bool Bin_prot.Type_class.writer`
`val __bin_read_sexp_bool__ : (Core_kernel__.Import.int ‑> Core_kernel__.Import.bool) Bin_prot.Read.reader`
`val bin_read_sexp_bool : Core_kernel__.Import.bool Bin_prot.Read.reader`
`val bin_reader_sexp_bool : Core_kernel__.Import.bool Bin_prot.Type_class.reader`
`val bin_sexp_bool : Core_kernel__.Import.bool Bin_prot.Type_class.t`
`val compare_sexp_bool : sexp_bool ‑> sexp_bool ‑> Core_kernel__.Import.int`
`val hash_fold_sexp_bool : Ppx_hash_lib.Std.Hash.state ‑> sexp_bool ‑> Ppx_hash_lib.Std.Hash.state`
`val hash_sexp_bool : sexp_bool ‑> Ppx_hash_lib.Std.Hash.hash_value`
`module Typename_of_sexp_bool = Core_kernel__Std_internal.Typename_of_sexp_bool`
`val typename_of_sexp_bool : sexp_bool Typerep_lib.Typename.t`
`val typerep_of_sexp_bool : sexp_bool Typerep_lib.Std.Typerep.t`
`type 'a sexp_list``= 'a Core_kernel__.Import.list```
`val bin_shape_sexp_list : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val bin_size_sexp_list : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.list ‑> int`
`val bin_write_sexp_list : 'a Bin_prot.Write.writer ‑> Bin_prot.Common.buf ‑> pos:Bin_prot.Common.pos ‑> 'a Core_kernel__.Import.list ‑> Bin_prot.Common.pos`
`val bin_writer_sexp_list : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.writer`
`val __bin_read_sexp_list__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.list`
`val bin_read_sexp_list : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> 'a Core_kernel__.Import.list`
`val bin_reader_sexp_list : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.reader`
`val bin_sexp_list : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.list Bin_prot.Type_class.t`
`val compare_sexp_list : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a sexp_list ‑> 'a sexp_list ‑> Core_kernel__.Import.int`
`val hash_fold_sexp_list : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a sexp_list ‑> Ppx_hash_lib.Std.Hash.state`
`module Typename_of_sexp_list = Core_kernel__Std_internal.Typename_of_sexp_list`
`val typename_of_sexp_list : 'a Typerep_lib.Typename.t ‑> 'a sexp_list Typerep_lib.Typename.t`
`val typerep_of_sexp_list : 'a Typerep_lib.Std.Typerep.t ‑> 'a sexp_list Typerep_lib.Std.Typerep.t`
`type 'a sexp_option``= 'a Core_kernel__.Import.option```
`val bin_shape_sexp_option : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val bin_size_sexp_option : 'a Bin_prot.Size.sizer ‑> 'a Core_kernel__.Import.option ‑> int`
`val bin_write_sexp_option : 'a Bin_prot.Write.writer ‑> Bin_prot.Common.buf ‑> pos:Bin_prot.Common.pos ‑> 'a Core_kernel__.Import.option ‑> Bin_prot.Common.pos`
`val bin_writer_sexp_option : 'a Bin_prot.Type_class.writer ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.writer`
`val __bin_read_sexp_option__ : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> Core_kernel__.Import.int ‑> 'a Core_kernel__.Import.option`
`val bin_read_sexp_option : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> 'a Core_kernel__.Import.option`
`val bin_reader_sexp_option : 'a Bin_prot.Type_class.reader ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.reader`
`val bin_sexp_option : 'a Bin_prot.Type_class.t ‑> 'a Core_kernel__.Import.option Bin_prot.Type_class.t`
`val compare_sexp_option : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a sexp_option ‑> 'a sexp_option ‑> Core_kernel__.Import.int`
`val hash_fold_sexp_option : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a sexp_option ‑> Ppx_hash_lib.Std.Hash.state`
`module Typename_of_sexp_option = Core_kernel__Std_internal.Typename_of_sexp_option`
`val typename_of_sexp_option : 'a Typerep_lib.Typename.t ‑> 'a sexp_option Typerep_lib.Typename.t`
`val typerep_of_sexp_option : 'a Typerep_lib.Std.Typerep.t ‑> 'a sexp_option Typerep_lib.Std.Typerep.t`
`type 'a sexp_opaque``= 'a```
`val bin_shape_sexp_opaque : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val bin_size_sexp_opaque : 'a ‑> 'a`
`val bin_write_sexp_opaque : 'a ‑> 'a`
`val bin_writer_sexp_opaque : 'a Bin_prot.Type_class.writer ‑> 'a Bin_prot.Type_class.writer`
`val __bin_read_sexp_opaque__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos ref ‑> 'c ‑> 'd`
`val bin_read_sexp_opaque : 'a ‑> 'a`
`val bin_reader_sexp_opaque : 'a Bin_prot.Type_class.reader ‑> 'a Bin_prot.Type_class.reader`
`val bin_sexp_opaque : 'a Bin_prot.Type_class.t ‑> 'a Bin_prot.Type_class.t`
`val compare_sexp_opaque : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a sexp_opaque ‑> 'a sexp_opaque ‑> Core_kernel__.Import.int`
`val hash_fold_sexp_opaque : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a sexp_opaque ‑> Ppx_hash_lib.Std.Hash.state`
`module Typename_of_sexp_opaque = Core_kernel__Std_internal.Typename_of_sexp_opaque`
`val typename_of_sexp_opaque : 'a Typerep_lib.Typename.t ‑> 'a sexp_opaque Typerep_lib.Typename.t`
`val typerep_of_sexp_opaque : 'a Typerep_lib.Std.Typerep.t ‑> 'a sexp_opaque Typerep_lib.Std.Typerep.t`
`exception` `Not_found`

- Deprecated [since 2018-02] Instead of raising [Not_found], consider using [raise_s] with an informative error message. If code needs to distinguish [Not_found] from other exceptions, please change it to handle both [Not_found] and [Not_found_s]. Then, instead of raising [Not_found], raise [Not_found_s] with an informative error message.

`exception` `Not_found_s of Sexplib0.Sexp.t`
`module Bigbuffer = Core__.Bigbuffer`
`module Bigstring = Core__.Bigstring`
`module Bigstring_marshal = Core__.Bigstring_marshal`
`module Caml = Core__.Caml`
`module Command = Core__.Command`
`module Condition = Core__.Core_condition`
`module Core_stable = Core__.Stable`
`module Crc = Core__.Crc`
`module Daemon = Core__.Daemon`
`module Date = Core__.Core_date`
`module Filename = Core__.Core_filename`
`module Interval = Core__.Interval`
`module Interval_intf = Core__.Interval_intf`
`module Iobuf = Core__.Iobuf`
`module Iobuf_debug = Core__.Iobuf_debug`
`module Iobuf_intf = Core__.Iobuf_intf`
`module Linux_ext = Core__.Linux_ext`
`module Lock_file = Core__.Lock_file`
`module Mac_address = Core__.Mac_address`
`module Md5 = Core__.Md5`
`module Digest = Md5`
`module Mutex = Core__.Core_mutex`
`module Nano_mutex = Core__.Nano_mutex`
`module Piecewise_linear = Core__.Piecewise_linear`
`module Process_env = Core__.Process_env`
`module Schedule_v4_deprecated = Core__.Schedule_v4_deprecated`
`module Schedule_v5 = Core__.Schedule_v5`
`module Signal = Core__.Signal`
`module Squeue = Core__.Squeue`
`module Sys = Core__.Core_sys`
`module Thread = Core__.Core_thread`
`module Time = Core__.Core_time_float`
`module Time_common = Core__.Time_common`
`module Time_ns = Core__.Core_time_ns`
`module Time_stamp_counter = Core__.Time_stamp_counter`
`module Timing_wheel_float = Core__.Timing_wheel_float`
`module Unix = Core__.Core_unix`
`module User_and_group = Core__.User_and_group`
`module Uuid = Core__.Uuid`
`module Version_util = Core__.Version_util`
`module Weak_hashtbl = Core__.Weak_hashtbl`
`val sec : Core_kernel__.Import.float ‑> Time.Span.t`
`val (^/) : string ‑> string ‑> string`
`val compare : No_polymorphic_compare.compare`
`val equal : No_polymorphic_compare.compare`
`val (=) : No_polymorphic_compare.compare`
`val failwith : 'a ‑> [ `use_Logging_die_instead ]`
`val failwithf : 'a ‑> [ `use_Logging_die_instead ]`
`val invalid_arg : 'a ‑> [ `use_Logging_die_instead ]`
`val invalid_argf : 'a ‑> [ `use_Logging_die_instead ]`
`val exit : [> `In_general_prefer_using_Logging_exit_over_Pervasives_exit ]`
`module ANSITerminal : module type of ANSITerminal`