sig
  module It_IO :
    sig
      type +'a m
      val return : 'a -> 'a It_type.IT.It_IO.m
      val bind :
        ('a -> 'b It_type.IT.It_IO.m) ->
        'a It_type.IT.It_IO.m -> 'b It_type.IT.It_IO.m
      val bind_rev :
        'a It_type.IT.It_IO.m ->
        ('a -> 'b It_type.IT.It_IO.m) -> 'b It_type.IT.It_IO.m
      val error : exn -> 'a It_type.IT.It_IO.m
      val catch :
        (unit -> 'a It_type.IT.It_IO.m) ->
        (exn -> 'a It_type.IT.It_IO.m) -> 'a It_type.IT.It_IO.m
      type output_channel
      val stdout : It_type.IT.It_IO.output_channel
      val write :
        It_type.IT.It_IO.output_channel -> string -> unit It_type.IT.It_IO.m
      type input_channel
      val open_in :
        string -> It_type.IT.It_IO.input_channel It_type.IT.It_IO.m
      val close_in :
        It_type.IT.It_IO.input_channel -> unit It_type.IT.It_IO.m
      val read_into :
        It_type.IT.It_IO.input_channel ->
        string -> int -> int -> int It_type.IT.It_IO.m
      val runIO : 'a It_type.IT.It_IO.m -> [ `Error of exn | `Ok of 'a ]
    end
  module Subarray :
    sig
      module C :
        sig
          type 'a t = private { arr : 'a array; ofs : int; len : int; }
          val empty : 'a It_type.IT.Subarray.C.t
          val mk :
            arr:'a array -> ofs:int -> len:int -> 'a It_type.IT.Subarray.C.t
        end
      type 'a t =
        'a It_type.IT.Subarray.C.t = private {
        arr : 'a array;
        ofs : int;
        len : int;
      }
      val length : 'a It_type.IT.Subarray.t -> int
      val get : 'a It_type.IT.Subarray.t -> int -> 'a
      val empty : 'a It_type.IT.Subarray.C.t
      val replace_with_substring :
        char array -> string -> int -> int -> char It_type.IT.Subarray.C.t
      val of_string : string -> char It_type.IT.Subarray.C.t
      val of_array : 'a array -> 'a It_type.IT.Subarray.C.t
      val of_array_sub : 'a array -> int -> int -> 'a It_type.IT.Subarray.C.t
      val of_list : 'a list -> 'a It_type.IT.Subarray.C.t
      val of_elem : 'a -> 'a It_type.IT.Subarray.C.t
      type dir = Subarray.dir = L | R
      val fold :
        It_type.IT.Subarray.dir ->
        ('a -> 'b -> 'a) -> 'a -> 'b It_type.IT.Subarray.C.t -> 'a
      val iter : ('a -> unit) -> 'a It_type.IT.Subarray.C.t -> unit
      val to_list : 'a It_type.IT.Subarray.C.t -> 'a list
      val to_string : char It_type.IT.Subarray.C.t -> string
      val append_to_list_rev :
        'a It_type.IT.Subarray.C.t -> 'a list -> 'a list
      val get_first_item : 'a It_type.IT.Subarray.C.t -> 'a option
      val destruct_first_item :
        'a It_type.IT.Subarray.C.t ->
        ('a * 'a It_type.IT.Subarray.C.t) option
      val sub :
        'a It_type.IT.Subarray.C.t ->
        ofs:int -> len:int -> 'a It_type.IT.Subarray.C.t
      val split_at :
        int ->
        'a It_type.IT.Subarray.C.t ->
        'a It_type.IT.Subarray.C.t * 'a It_type.IT.Subarray.C.t
      val drop :
        int -> 'a It_type.IT.Subarray.C.t -> 'a It_type.IT.Subarray.C.t
      val break :
        ('a -> bool) ->
        'a It_type.IT.Subarray.C.t ->
        'a It_type.IT.Subarray.C.t * 'a It_type.IT.Subarray.C.t
      val break_limit :
        limit:int ->
        ('a -> bool) ->
        'a It_type.IT.Subarray.C.t ->
        [> `Found of 'a It_type.IT.Subarray.C.t * 'a It_type.IT.Subarray.C.t
         | `Hit_end
         | `Hit_limit ]
      val drop_while :
        ('a -> bool) ->
        'a It_type.IT.Subarray.C.t -> 'a It_type.IT.Subarray.C.t
      val is_empty : 'a It_type.IT.Subarray.C.t -> bool
      val buffer_add : Buffer.t -> char It_type.IT.Subarray.C.t -> unit
      val map :
        ('a -> 'b) ->
        'a It_type.IT.Subarray.C.t -> 'b It_type.IT.Subarray.C.t
      val copy : 'a It_type.IT.Subarray.C.t -> 'a It_type.IT.Subarray.C.t
      val concat_splitted :
        'a It_type.IT.Subarray.C.t ->
        'a It_type.IT.Subarray.C.t -> 'a It_type.IT.Subarray.C.t
    end
  module S :
    sig
      module C :
        sig
          type 'a t =
            'a It_type.IT.Subarray.C.t = private {
            arr : 'a array;
            ofs : int;
            len : int;
          }
          val empty : 'a It_type.IT.S.C.t
          val mk : arr:'a array -> ofs:int -> len:int -> 'a It_type.IT.S.C.t
        end
      type 'a t =
        'a It_type.IT.Subarray.C.t = private {
        arr : 'a array;
        ofs : int;
        len : int;
      }
      val length : 'a It_type.IT.S.t -> int
      val get : 'a It_type.IT.S.t -> int -> 'a
      val empty : 'a It_type.IT.S.C.t
      val replace_with_substring :
        char array -> string -> int -> int -> char It_type.IT.S.C.t
      val of_string : string -> char It_type.IT.S.C.t
      val of_array : 'a array -> 'a It_type.IT.S.C.t
      val of_array_sub : 'a array -> int -> int -> 'a It_type.IT.S.C.t
      val of_list : 'a list -> 'a It_type.IT.S.C.t
      val of_elem : 'a -> 'a It_type.IT.S.C.t
      type dir = It_type.IT.Subarray.dir = L | R
      val fold :
        It_type.IT.S.dir ->
        ('a -> 'b -> 'a) -> 'a -> 'b It_type.IT.S.C.t -> 'a
      val iter : ('a -> unit) -> 'a It_type.IT.S.C.t -> unit
      val to_list : 'a It_type.IT.S.C.t -> 'a list
      val to_string : char It_type.IT.S.C.t -> string
      val append_to_list_rev : 'a It_type.IT.S.C.t -> 'a list -> 'a list
      val get_first_item : 'a It_type.IT.S.C.t -> 'a option
      val destruct_first_item :
        'a It_type.IT.S.C.t -> ('a * 'a It_type.IT.S.C.t) option
      val sub :
        'a It_type.IT.S.C.t -> ofs:int -> len:int -> 'a It_type.IT.S.C.t
      val split_at :
        int ->
        'a It_type.IT.S.C.t -> 'a It_type.IT.S.C.t * 'a It_type.IT.S.C.t
      val drop : int -> 'a It_type.IT.S.C.t -> 'a It_type.IT.S.C.t
      val break :
        ('a -> bool) ->
        'a It_type.IT.S.C.t -> 'a It_type.IT.S.C.t * 'a It_type.IT.S.C.t
      val break_limit :
        limit:int ->
        ('a -> bool) ->
        'a It_type.IT.S.C.t ->
        [> `Found of 'a It_type.IT.S.C.t * 'a It_type.IT.S.C.t
         | `Hit_end
         | `Hit_limit ]
      val drop_while :
        ('a -> bool) -> 'a It_type.IT.S.C.t -> 'a It_type.IT.S.C.t
      val is_empty : 'a It_type.IT.S.C.t -> bool
      val buffer_add : Buffer.t -> char It_type.IT.S.C.t -> unit
      val map : ('a -> 'b) -> 'a It_type.IT.S.C.t -> 'b It_type.IT.S.C.t
      val copy : 'a It_type.IT.S.C.t -> 'a It_type.IT.S.C.t
      val concat_splitted :
        'a It_type.IT.S.C.t -> 'a It_type.IT.S.C.t -> 'a It_type.IT.S.C.t
    end
  type err_msg = exn
  exception EIO of (exn * It_Types.place)
  exception Iteratees_err_msg of It_type.IT.err_msg
  exception Divergent_iteratee of It_Types.place
  val ierr_of_merr : It_type.IT.err_msg -> It_type.IT.err_msg
  type 'a stream =
      EOF of It_type.IT.err_msg option
    | Chunk of 'a It_type.IT.Subarray.t
  val chunk_of : 'a -> 'a It_type.IT.stream
  val dbgstream : ?addon:string -> 'a It_type.IT.stream -> string
  val dbgstream_char : ?body:int -> char It_type.IT.stream -> string
  val ( >>% ) :
    'a It_type.IT.It_IO.m ->
    ('a -> 'b It_type.IT.It_IO.m) -> 'b It_type.IT.It_IO.m
  val ( %<< ) :
    ('a -> 'b It_type.IT.It_IO.m) ->
    'a It_type.IT.It_IO.m -> 'b It_type.IT.It_IO.m
  module Sl :
    sig
      type 'a sl
      val empty : 'a It_type.IT.Sl.sl
      val destr_head :
        'a It_type.IT.Sl.sl ->
        ('a It_type.IT.stream * 'a It_type.IT.Sl.sl) option
      val cons :
        'a It_type.IT.stream -> 'a It_type.IT.Sl.sl -> 'a It_type.IT.Sl.sl
      val get_one_opt : 'a It_type.IT.Sl.sl -> 'a It_type.IT.stream option
      val one : 'a It_type.IT.stream -> 'a It_type.IT.Sl.sl
      val dbgsl : 'a It_type.IT.Sl.sl -> string
    end
  type 'a sl = 'a It_type.IT.Sl.sl
  type ('a, 'b) iteratee =
      IE_done of 'b
    | IE_cont of It_type.IT.err_msg option *
        ('a It_type.IT.stream ->
         (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m)
  val return : 'a -> ('b, 'a) It_type.IT.iteratee
  val bindI :
    ('a -> ('b, 'c) It_type.IT.iteratee) ->
    ('b, 'a) It_type.IT.iteratee -> ('b, 'c) It_type.IT.iteratee
  val ( =<< ) :
    ('a -> ('b, 'c) It_type.IT.iteratee) ->
    ('b, 'a) It_type.IT.iteratee -> ('b, 'c) It_type.IT.iteratee
  val ( >>= ) :
    ('a, 'b) It_type.IT.iteratee ->
    ('b -> ('a, 'c) It_type.IT.iteratee) -> ('a, 'c) It_type.IT.iteratee
  val lift : 'a It_type.IT.It_IO.m -> ('b, 'a) It_type.IT.iteratee
  val throw_err : It_type.IT.err_msg -> ('a, 'b) It_type.IT.iteratee
  val throw_err_cont :
    It_type.IT.err_msg ->
    'a It_type.IT.stream ->
    (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m
  val throw_recoverable_err :
    It_type.IT.err_msg ->
    ('a It_type.IT.stream ->
     (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m) ->
    ('a, 'b) It_type.IT.iteratee
  val set_eof : 'a It_type.IT.stream -> It_type.IT.err_msg
  val empty_stream : 'a It_type.IT.stream
  val ie_doneM :
    'a ->
    'b It_type.IT.stream ->
    (('b, 'a) It_type.IT.iteratee * 'b It_type.IT.sl) It_type.IT.It_IO.m
  val ie_contM :
    ('a It_type.IT.stream ->
     (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m) ->
    (('a, 'b) It_type.IT.iteratee * 'c It_type.IT.Sl.sl) It_type.IT.It_IO.m
  val ie_doneMsl :
    'a -> 'b -> (('c, 'a) It_type.IT.iteratee * 'b) It_type.IT.It_IO.m
  val ie_errorMsl :
    It_type.IT.err_msg ->
    'a It_type.IT.sl ->
    (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m
  val ie_cont :
    ('a It_type.IT.stream ->
     (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m) ->
    ('a, 'b) It_type.IT.iteratee
  val liftI :
    ('a, 'b) It_type.IT.iteratee It_type.IT.It_IO.m ->
    ('a, 'b) It_type.IT.iteratee
  val merr_of_ierr : It_type.IT.err_msg -> 'a It_type.IT.It_IO.m
  val joinI :
    ('a, ('b, 'c) It_type.IT.iteratee) It_type.IT.iteratee ->
    ('a, 'c) It_type.IT.iteratee
  val run : ('a, 'b) It_type.IT.iteratee -> 'b It_type.IT.It_IO.m
  val stream2list : ('a, 'a list) It_type.IT.iteratee
  val get_stream_eof :
    ('a, It_type.IT.err_msg option option) It_type.IT.iteratee
  val is_stream_finished :
    ('a, It_type.IT.err_msg option) It_type.IT.iteratee
  val break_fold :
    ('a -> bool) -> ('b -> 'a -> 'b) -> 'b -> ('a, 'b) It_type.IT.iteratee
  val mapI :
    ('a -> 'b) ->
    ('c, 'a) It_type.IT.iteratee -> ('c, 'b) It_type.IT.iteratee
  val break : ('a -> bool) -> ('a, 'a list) It_type.IT.iteratee
  val prepend :
    (unit -> 'a) ->
    ('a -> ('b, 'c) It_type.IT.iteratee) -> ('b, 'c) It_type.IT.iteratee
  val break_chars : (char -> bool) -> (char, string) It_type.IT.iteratee
  val drop_while : ('a -> bool) -> ('a, unit) It_type.IT.iteratee
  val peek : ('a, 'a option) It_type.IT.iteratee
  val head : ('a, 'a) It_type.IT.iteratee
  val pervasives_eq : 'a -> 'a -> bool
  val heads :
    ?eq:('a -> 'a -> bool) -> 'a list -> ('a, int) It_type.IT.iteratee
  val skip_till_eof : ('a, unit) It_type.IT.iteratee
  val drop_step :
    int ->
    'a It_type.IT.stream ->
    (('a, unit) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m
  val drop : int -> ('a, unit) It_type.IT.iteratee
  val io_iter :
    ('a -> unit It_type.IT.It_IO.m) -> 'a list -> unit It_type.IT.It_IO.m
  val print_line : string -> unit It_type.IT.It_IO.m
  type ('a, 'b) enumerator =
      ('a, 'b) It_type.IT.iteratee ->
      ('a, 'b) It_type.IT.iteratee It_type.IT.It_IO.m
  val enum_eof : ('a, 'b) It_type.IT.enumerator
  val enum_err : It_type.IT.err_msg -> ('a, 'b) It_type.IT.enumerator
  val ( >>> ) :
    ('a, 'b) It_type.IT.enumerator ->
    ('a, 'b) It_type.IT.enumerator -> ('a, 'b) It_type.IT.enumerator
  val enum_pure_1chunk : 'a list -> ('a, 'b) It_type.IT.enumerator
  val enum_pure_nchunk : 'a list -> int -> ('a, 'b) It_type.IT.enumerator
  val enum_string :
    ?chunk_size:int -> string -> (char, 'a) It_type.IT.enumerator
  val mprintf :
    ('a, unit, string, unit It_type.IT.It_IO.m) Pervasives.format4 -> 'a
  val mres : 'a It_type.IT.It_IO.m -> 'a It_Types.res It_type.IT.It_IO.m
  val _munres : 'a It_Types.res -> 'a It_type.IT.It_IO.m
  val enum_readchars :
    buffer_size:int ->
    read_func:('a -> string -> int -> int -> int It_type.IT.It_IO.m) ->
    'a -> (char, 'b) It_type.IT.enumerator
  val enum_fd :
    It_type.IT.It_IO.input_channel -> (char, 'a) It_type.IT.enumerator
  val enum_file : string -> (char, 'a) It_type.IT.enumerator
  type ('a, 'b, 'c) enumeratee =
      ('b, 'c) It_type.IT.iteratee ->
      ('a, ('b, 'c) It_type.IT.iteratee) It_type.IT.iteratee
  val take_gen :
    [ `Drop | `Fail ] -> int -> ('a, 'a, 'b) It_type.IT.enumeratee
  val take :
    int ->
    ('a, 'b) It_type.IT.iteratee ->
    ('a, ('a, 'b) It_type.IT.iteratee) It_type.IT.iteratee
  val take_or_fail :
    int ->
    ('a, 'b) It_type.IT.iteratee ->
    ('a, ('a, 'b) It_type.IT.iteratee) It_type.IT.iteratee
  val map_stream : ('a -> 'b) -> ('a, 'b, 'c) It_type.IT.enumeratee
  val sequence_stream :
    ('a, 'b) It_type.IT.iteratee -> ('a, 'b, 'c) It_type.IT.enumeratee
  val enum_words : (char, string, 'a) It_type.IT.enumeratee
  val array_ensure_size :
    default:'a -> 'a array Pervasives.ref -> int -> 'a array
  module SC :
    sig
      type 'a t = 'a Subarray_cat.t
      val make : 'a It_type.IT.Subarray.t list -> 'a It_type.IT.SC.t
      val length : 'a It_type.IT.SC.t -> int
      val get : 'a It_type.IT.SC.t -> int -> 'a
      val sub_copy_out :
        ?ofs:int ->
        ?len:int -> 'a It_type.IT.SC.t -> 'a It_type.IT.Subarray.t
      val append :
        'a It_type.IT.SC.t -> 'a It_type.IT.Subarray.t -> 'a It_type.IT.SC.t
    end
  type uchar = int
  module UTF8 :
    sig
      val utf8_of_char : (char, It_type.IT.uchar, 'a) It_type.IT.enumeratee
    end
  val break_copy :
    cpred:(char -> bool) ->
    outch:It_type.IT.It_IO.output_channel -> (char, unit) It_type.IT.iteratee
  val break_limit :
    pred:('a -> bool) ->
    limit:int ->
    ('a, [ `Found | `Hit_eof | `Hit_limit ] * 'a It_type.IT.Subarray.t)
    It_type.IT.iteratee
  val limit : int -> ('a, 'a, 'b) It_type.IT.enumeratee
  val catchk :
    (unit -> ('a, 'b) It_type.IT.iteratee) ->
    (It_type.IT.err_msg ->
     ('a It_type.IT.stream ->
      (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m) ->
     ('a, 'b) It_type.IT.iteratee) ->
    ('a, 'b) It_type.IT.iteratee
  val catch :
    (unit -> ('a, 'b) It_type.IT.iteratee) ->
    (It_type.IT.err_msg -> ('a, 'b) It_type.IT.iteratee) ->
    ('a, 'b) It_type.IT.iteratee
  val printf :
    ('a, unit, string, ('b, unit) It_type.IT.iteratee) Pervasives.format4 ->
    'a
  val gather_to_string : (char, string) It_type.IT.iteratee
  module Ops :
    sig
      val ( %<< ) :
        ('a -> 'b It_type.IT.It_IO.m) ->
        'a It_type.IT.It_IO.m -> 'b It_type.IT.It_IO.m
      val ( >>% ) :
        'a It_type.IT.It_IO.m ->
        ('a -> 'b It_type.IT.It_IO.m) -> 'b It_type.IT.It_IO.m
      val ( =<< ) :
        ('a -> ('b, 'c) It_type.IT.iteratee) ->
        ('b, 'a) It_type.IT.iteratee -> ('b, 'c) It_type.IT.iteratee
      val ( >>= ) :
        ('a, 'b) It_type.IT.iteratee ->
        ('b -> ('a, 'c) It_type.IT.iteratee) -> ('a, 'c) It_type.IT.iteratee
      val ( >>> ) :
        ('a, 'b) It_type.IT.enumerator ->
        ('a, 'b) It_type.IT.enumerator -> ('a, 'b) It_type.IT.enumerator
    end
  val feedI :
    ('a It_type.IT.stream ->
     (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m) ->
    'a It_type.IT.stream -> ('a, 'b) It_type.IT.iteratee It_type.IT.It_IO.m
  val feed_it :
    ('a, 'b) It_type.IT.iteratee ->
    'a It_type.IT.stream -> ('a, 'b) It_type.IT.iteratee
  exception Itlist_empty
  module Anyresult_lasterror :
    sig
      val itlist_step_firstresult_lasterror :
        ('a, 'b) It_type.IT.iteratee list ->
        'a It_type.IT.stream ->
        [ `Cont of ('a, 'b) It_type.IT.iteratee list
        | `First_result of ('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl
        | `Last_error of It_type.IT.err_msg ] It_type.IT.It_IO.m
      val get_any_done :
        ('a, 'b) It_type.IT.iteratee list ->
        ('c, 'b) It_type.IT.iteratee option
      val itlist_anyresult_lasterror :
        ('a, 'b) It_type.IT.iteratee list -> ('a, 'b) It_type.IT.iteratee
    end
  val itlist_anyresult_lasterror :
    ('a, 'b) It_type.IT.iteratee list -> ('a, 'b) It_type.IT.iteratee
  val junk : ('a, unit) It_type.IT.iteratee
  exception SInt_overflow
  exception SInt_not_a_number of string
  module Reading_ints :
    sig
      val read_uint : (char, int) It_type.IT.iteratee
      val read_uint_nz : (char, int) It_type.IT.iteratee
      val read_int : (char, int) It_type.IT.iteratee
      val read_int_nz : (char, int) It_type.IT.iteratee
      val read_uint32 : (char, int32) It_type.IT.iteratee
      val read_uint32_nz : (char, int32) It_type.IT.iteratee
      val read_int32 : (char, int32) It_type.IT.iteratee
      val read_int32_nz : (char, int32) It_type.IT.iteratee
      val read_uint64 : (char, int64) It_type.IT.iteratee
      val read_uint64_nz : (char, int64) It_type.IT.iteratee
      val read_int64 : (char, int64) It_type.IT.iteratee
      val read_int64_nz : (char, int64) It_type.IT.iteratee
    end
  val read_uint : (char, int) It_type.IT.iteratee
  val read_uint_nz : (char, int) It_type.IT.iteratee
  val read_int : (char, int) It_type.IT.iteratee
  val read_int_nz : (char, int) It_type.IT.iteratee
  val read_uint32 : (char, int32) It_type.IT.iteratee
  val read_uint32_nz : (char, int32) It_type.IT.iteratee
  val read_int32 : (char, int32) It_type.IT.iteratee
  val read_int32_nz : (char, int32) It_type.IT.iteratee
  val read_uint64 : (char, int64) It_type.IT.iteratee
  val read_uint64_nz : (char, int64) It_type.IT.iteratee
  val read_int64 : (char, int64) It_type.IT.iteratee
  val read_int64_nz : (char, int64) It_type.IT.iteratee
  module type NUM =
    sig
      type num
      val num_of_int : int -> It_type.IT.NUM.num
      val mult_num :
        It_type.IT.NUM.num -> It_type.IT.NUM.num -> It_type.IT.NUM.num
      val power_num :
        It_type.IT.NUM.num -> It_type.IT.NUM.num -> It_type.IT.NUM.num
      val num_of_string : string -> It_type.IT.NUM.num
    end
  module Reading_num :
    functor (Num : NUM) ->
      sig
        val num_fix_unsigned : (char, Num.num) It_type.IT.iteratee
        val num_fix : (char, Num.num) It_type.IT.iteratee
        val num_of_string_fix : string -> Num.num It_type.IT.It_IO.m
      end
  module Base64 :
    sig
      val base64_conv_table : string
      exception Bad_encoding
      val base64_decode_char : char -> int
      val base64_decode_piece :
        ibuf:int array -> arr_to:char array -> arr_ofs:int -> unit
      val base64_decode :
        s_from:char It_type.IT.S.t ->
        arr_to:char array ->
        ibuf:int array -> ipos:int Pervasives.ref -> int * bool * bool
      val base64_decode_last :
        arr_to:char array -> ibuf:int array -> ipos_val:int -> int * bool
      val enee_cont :
        ('a, 'b) It_type.IT.iteratee ->
        (('a It_type.IT.stream ->
          (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl)
          It_type.IT.It_IO.m) ->
         ('c, ('a, 'b) It_type.IT.iteratee) It_type.IT.iteratee) ->
        ('c, ('a, 'b) It_type.IT.iteratee) It_type.IT.iteratee
      val enee_cont_io :
        ('a, 'b) It_type.IT.iteratee ->
        (('a It_type.IT.stream ->
          (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl)
          It_type.IT.It_IO.m) ->
         (('c, ('a, 'b) It_type.IT.iteratee) It_type.IT.iteratee *
          'c It_type.IT.sl)
         It_type.IT.It_IO.m) ->
        (('c, ('a, 'b) It_type.IT.iteratee) It_type.IT.iteratee *
         'c It_type.IT.sl)
        It_type.IT.It_IO.m
      val enee_base64_decode :
        (char, 'a) It_type.IT.iteratee ->
        (char, (char, 'a) It_type.IT.iteratee) It_type.IT.iteratee
      val step :
        int array ->
        int Pervasives.ref ->
        char array Pervasives.ref ->
        (char It_type.IT.stream ->
         ((char, 'a) It_type.IT.iteratee * char It_type.IT.sl)
         It_type.IT.It_IO.m) ->
        char It_type.IT.stream ->
        ((char, (char, 'a) It_type.IT.iteratee) It_type.IT.iteratee *
         char It_type.IT.sl)
        It_type.IT.It_IO.m
      val finish :
        obuf:char array Pervasives.ref ->
        ibuf:int array ->
        ipos:int Pervasives.ref ->
        opt_err:It_type.IT.err_msg option ->
        (char It_type.IT.stream ->
         ((char, 'a) It_type.IT.iteratee * char It_type.IT.sl)
         It_type.IT.It_IO.m) ->
        ((char, (char, 'a) It_type.IT.iteratee) It_type.IT.iteratee *
         char It_type.IT.sl)
        It_type.IT.It_IO.m
      val pass_obuf :
        written:int ->
        arr_to:char array ->
        (char It_type.IT.stream ->
         ((char, 'a) It_type.IT.iteratee * char It_type.IT.sl)
         It_type.IT.It_IO.m) ->
        (char, 'a) It_type.IT.iteratee It_type.IT.It_IO.m
      val ret :
        opt_err:It_type.IT.err_msg option ->
        (char It_type.IT.stream ->
         ((char, 'a) It_type.IT.iteratee * char It_type.IT.sl)
         It_type.IT.It_IO.m) ->
        ((char, (char, 'a) It_type.IT.iteratee) It_type.IT.iteratee *
         char It_type.IT.sl)
        It_type.IT.It_IO.m
    end
  val base64_decode :
    (char, 'a) It_type.IT.iteratee ->
    (char, (char, 'a) It_type.IT.iteratee) It_type.IT.iteratee
  module Deque_stream :
    sig
      type 'a t
      val empty : 'a It_type.IT.Deque_stream.t
      val cons :
        int ->
        'a It_type.IT.stream ->
        'a It_type.IT.Deque_stream.t -> 'a It_type.IT.Deque_stream.t
      val cons_sl :
        'a It_type.IT.sl ->
        'a It_type.IT.Deque_stream.t -> 'a It_type.IT.Deque_stream.t
      val snoc :
        'a It_type.IT.Deque_stream.t ->
        int -> 'a It_type.IT.stream -> 'a It_type.IT.Deque_stream.t
      val concat : 'a It_type.IT.Deque_stream.t -> 'a It_type.IT.sl
      val destr_head :
        'a It_type.IT.Deque_stream.t ->
        ((int * 'a It_type.IT.stream) * 'a It_type.IT.Deque_stream.t) option
      val is_empty : 'a It_type.IT.Deque_stream.t -> bool
    end
  val fdbg : ('a, unit, string, unit) Pervasives.format4 -> 'a
  val break_subsequence :
    ('a It_type.IT.S.t ->
     int ->
     (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m
     option) ->
    ('a, 'c) It_type.IT.iteratee ->
    ('a, 'b option * ('a, 'c) It_type.IT.iteratee) It_type.IT.iteratee
  val it_ignore : ('a, unit) It_type.IT.iteratee
  val it_ignore_step :
    'a It_type.IT.stream ->
    (('a, unit) It_type.IT.iteratee * 'a It_type.IT.sl) It_type.IT.It_IO.m
  val map_ready :
    ('a, 'b) It_type.IT.iteratee -> ('c, 'b) It_type.IT.iteratee
  val eof_to_res :
    ('a, 'b) It_type.IT.iteratee ->
    It_type.IT.err_msg option ->
    ('c, [ `Error of It_type.IT.err_msg | `Ok of 'b ]) It_type.IT.iteratee
  val probe_string :
    string ->
    char It_type.IT.S.t ->
    int ->
    ((char, unit) It_type.IT.iteratee * char It_type.IT.sl)
    It_type.IT.It_IO.m option
  val it_last : int -> ('a, 'a list) It_type.IT.iteratee
  type ('a, 'b) enumpart =
      'a It_type.IT.sl ->
      ('a, 'b) It_type.IT.iteratee -> ('a, 'b) It_type.IT.enumpart_ret
  and ('a, 'b) enumpart_ret =
      (('a, 'b) It_type.IT.iteratee * 'a It_type.IT.sl Lazy.t *
       'a It_type.IT.opt_enumpart)
      It_type.IT.It_IO.m
  and 'a opt_enumpart = EP_None | EP_Some of 'a It_type.IT.enumpart_poly
  and 'a enumpart_poly = {
    enumpart_poly : 'b. ('a, 'b) It_type.IT.enumpart;
  }
  val enumpart_readchars :
    buffer_size:int ->
    read_func:('a -> string -> int -> int -> int It_type.IT.It_IO.m) ->
    'a -> (char, 'b) It_type.IT.enumpart
  type it_exact = [ `Done | `Eof of int * It_type.IT.err_msg option ]
  val take_exact :
    int ->
    ('a, 'b) It_type.IT.iteratee ->
    ('a, It_type.IT.it_exact * ('a, 'b) It_type.IT.iteratee)
    It_type.IT.iteratee
end