sig
  type 'a t = ('a -> unit) -> unit
  type 'a sequence = 'a Sequence.t
  type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
  type 'a equal = 'a -> 'a -> bool
  type 'a hash = 'a -> int
  val from_iter : (('a -> unit) -> unit) -> 'a Sequence.t
  val from_fun : (unit -> 'a option) -> 'a Sequence.t
  val empty : 'a Sequence.t
  val singleton : 'a -> 'a Sequence.t
  val doubleton : 'a -> 'a -> 'a Sequence.t
  val init : (int -> 'a) -> 'a Sequence.t
  val cons : 'a -> 'a Sequence.t -> 'a Sequence.t
  val snoc : 'a Sequence.t -> 'a -> 'a Sequence.t
  val return : 'a -> 'a Sequence.t
  val pure : 'a -> 'a Sequence.t
  val repeat : 'a -> 'a Sequence.t
  val iterate : ('a -> 'a) -> 'a -> 'a Sequence.t
  val forever : (unit -> 'b) -> 'b Sequence.t
  val cycle : 'a Sequence.t -> 'a Sequence.t
  val iter : ('a -> unit) -> 'a Sequence.t -> unit
  val iteri : (int -> 'a -> unit) -> 'a Sequence.t -> unit
  val fold : ('a -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
  val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
  val fold_map :
    ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a Sequence.t -> 'b Sequence.t
  val fold_filter_map :
    ('acc -> 'a -> 'acc * 'b option) ->
    'acc -> 'a Sequence.t -> 'b Sequence.t
  val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
  val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
  val map_by_2 : ('a -> 'a -> 'a) -> 'a Sequence.t -> 'a Sequence.t
  val for_all : ('a -> bool) -> 'a Sequence.t -> bool
  val exists : ('a -> bool) -> 'a Sequence.t -> bool
  val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a Sequence.t -> bool
  val find : ('a -> 'b option) -> 'a Sequence.t -> 'b option
  val find_map : ('a -> 'b option) -> 'a Sequence.t -> 'b option
  val findi : (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b option
  val find_mapi : (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b option
  val find_pred : ('a -> bool) -> 'a Sequence.t -> 'a option
  val find_pred_exn : ('a -> bool) -> 'a Sequence.t -> 'a
  val length : 'a Sequence.t -> int
  val is_empty : 'a Sequence.t -> bool
  val filter : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
  val append : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
  val append_l : 'a Sequence.t list -> 'a Sequence.t
  val concat : 'a Sequence.t Sequence.t -> 'a Sequence.t
  val flatten : 'a Sequence.t Sequence.t -> 'a Sequence.t
  val flat_map : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
  val flat_map_l : ('a -> 'b list) -> 'a Sequence.t -> 'b Sequence.t
  val seq_list : 'a Sequence.t list -> 'a list Sequence.t
  val seq_list_map : ('a -> 'b Sequence.t) -> 'a list -> 'b list Sequence.t
  val filter_map : ('a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
  val filter_mapi :
    (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
  val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
  val persistent : 'a Sequence.t -> 'a Sequence.t
  val persistent_lazy : 'a Sequence.t -> 'a Sequence.t
  val sort : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
  val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
  val sorted : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> bool
  val group_succ_by :
    ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
  val group_by :
    ?hash:('a -> int) ->
    ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
  val count :
    ?hash:('a -> int) ->
    ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> ('a * int) Sequence.t
  val uniq : ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a Sequence.t
  val product : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t
  val diagonal_l : 'a list -> ('a * 'a) Sequence.t
  val diagonal : 'a Sequence.t -> ('a * 'a) Sequence.t
  val product2 : 'a Sequence.t -> 'b Sequence.t -> ('a, 'b) Sequence.t2
  val join :
    join_row:('a -> 'b -> 'c option) ->
    'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
  val join_by :
    ?eq:'key Sequence.equal ->
    ?hash:'key Sequence.hash ->
    ('a -> 'key) ->
    ('b -> 'key) ->
    merge:('key -> 'a -> 'b -> 'c option) ->
    'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
  val join_all_by :
    ?eq:'key Sequence.equal ->
    ?hash:'key Sequence.hash ->
    ('a -> 'key) ->
    ('b -> 'key) ->
    merge:('key -> 'a list -> 'b list -> 'c option) ->
    'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
  val group_join_by :
    ?eq:'a Sequence.equal ->
    ?hash:'a Sequence.hash ->
    ('b -> 'a) -> 'a Sequence.t -> 'b Sequence.t -> ('a * 'b list) Sequence.t
  val inter :
    ?eq:'a Sequence.equal ->
    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
  val union :
    ?eq:'a Sequence.equal ->
    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
  val diff :
    ?eq:'a Sequence.equal ->
    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
  val subset :
    ?eq:'a Sequence.equal ->
    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> bool
  val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a Sequence.t
  val scan : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b Sequence.t
  val max : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
  val max_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
  val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
  val min_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
  val sum : int Sequence.t -> int
  val sumf : float Sequence.t -> float
  val head : 'a Sequence.t -> 'a option
  val head_exn : 'a Sequence.t -> 'a
  val take : int -> 'a Sequence.t -> 'a Sequence.t
  val take_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
  val fold_while :
    ('a -> 'b -> 'a * [ `Continue | `Stop ]) -> 'a -> 'b Sequence.t -> 'a
  val drop : int -> 'a Sequence.t -> 'a Sequence.t
  val drop_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
  val rev : 'a Sequence.t -> 'a Sequence.t
  val empty2 : ('a, 'b) Sequence.t2
  val is_empty2 : ('a, 'b) Sequence.t2 -> bool
  val length2 : ('a, 'b) Sequence.t2 -> int
  val zip : ('a, 'b) Sequence.t2 -> ('a * 'b) Sequence.t
  val unzip : ('a * 'b) Sequence.t -> ('a, 'b) Sequence.t2
  val zip_i : 'a Sequence.t -> (int, 'a) Sequence.t2
  val fold2 : ('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) Sequence.t2 -> 'c
  val iter2 : ('a -> 'b -> unit) -> ('a, 'b) Sequence.t2 -> unit
  val map2 : ('a -> 'b -> 'c) -> ('a, 'b) Sequence.t2 -> 'c Sequence.t
  val map2_2 :
    ('a -> 'b -> 'c) ->
    ('a -> 'b -> 'd) -> ('a, 'b) Sequence.t2 -> ('c, 'd) Sequence.t2
  val to_list : 'a Sequence.t -> 'a list
  val to_rev_list : 'a Sequence.t -> 'a list
  val of_list : 'a list -> 'a Sequence.t
  val on_list : ('a Sequence.t -> 'b Sequence.t) -> 'a list -> 'b list
  val pair_with_idx : 'a Sequence.t -> (int * 'a) Sequence.t
  val to_opt : 'a Sequence.t -> 'a option
  val to_array : 'a Sequence.t -> 'a array
  val of_array : 'a array -> 'a Sequence.t
  val of_array_i : 'a array -> (int * 'a) Sequence.t
  val of_array2 : 'a array -> (int, 'a) Sequence.t2
  val array_slice : 'a array -> int -> int -> 'a Sequence.t
  val of_opt : 'a option -> 'a Sequence.t
  val of_stream : 'a Stream.t -> 'a Sequence.t
  val to_stream : 'a Sequence.t -> 'a Stream.t
  val to_stack : 'a Stack.t -> 'a Sequence.t -> unit
  val of_stack : 'a Stack.t -> 'a Sequence.t
  val to_queue : 'a Queue.t -> 'a Sequence.t -> unit
  val of_queue : 'a Queue.t -> 'a Sequence.t
  val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
  val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
  val to_hashtbl : ('a * 'b) Sequence.t -> ('a, 'b) Hashtbl.t
  val to_hashtbl2 : ('a, 'b) Sequence.t2 -> ('a, 'b) Hashtbl.t
  val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t
  val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) Sequence.t2
  val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a Sequence.t
  val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b Sequence.t
  val of_str : string -> char Sequence.t
  val to_str : char Sequence.t -> string
  val concat_str : string Sequence.t -> string
  exception OneShotSequence
  val of_in_channel : Pervasives.in_channel -> char Sequence.t
  val to_buffer : char Sequence.t -> Buffer.t -> unit
  val int_range : start:int -> stop:int -> int Sequence.t
  val int_range_dec : start:int -> stop:int -> int Sequence.t
  val int_range_by : step:int -> int -> int -> int Sequence.t
  val bools : bool Sequence.t
  val of_set :
    (module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a Sequence.t
  val to_set :
    (module Set.S with type elt = 'a and type t = 'b) -> 'a Sequence.t -> 'b
  type 'a gen = unit -> 'a option
  type 'a klist = unit -> [ `Cons of 'a * 'a Sequence.klist | `Nil ]
  val of_gen : 'a Sequence.gen -> 'a Sequence.t
  val to_gen : 'a Sequence.t -> 'a Sequence.gen
  val of_klist : 'a Sequence.klist -> 'a Sequence.t
  val to_klist : 'a Sequence.t -> 'a Sequence.klist
  module Set :
    sig
      module type S =
        sig
          type elt
          type t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val map : (elt -> elt) -> t -> t
          val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_seq : elt Sequence.sequence -> Sequence.t
          val to_seq : Sequence.t -> elt Sequence.sequence
          val to_list : Sequence.t -> elt list
          val of_list : elt list -> Sequence.t
        end
      module Adapt :
        functor (X : Set.S) ->
          sig
            type elt = X.elt
            type t = X.t
            val empty : t
            val is_empty : t -> bool
            val mem : elt -> t -> bool
            val add : elt -> t -> t
            val singleton : elt -> t
            val remove : elt -> t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val compare : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
            val for_all : (elt -> bool) -> t -> bool
            val exists : (elt -> bool) -> t -> bool
            val filter : (elt -> bool) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_seq : elt sequence -> t
            val to_seq : t -> elt sequence
            val to_list : t -> elt list
            val of_list : elt list -> t
          end
      module Make :
        functor (X : Set.OrderedType) ->
          sig
            type elt = X.t
            type t
            val empty : t
            val is_empty : t -> bool
            val mem : elt -> t -> bool
            val add : elt -> t -> t
            val singleton : elt -> t
            val remove : elt -> t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val compare : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
            val for_all : (elt -> bool) -> t -> bool
            val exists : (elt -> bool) -> t -> bool
            val filter : (elt -> bool) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_seq : elt sequence -> t
            val to_seq : t -> elt sequence
            val to_list : t -> elt list
            val of_list : elt list -> t
          end
    end
  module Map :
    sig
      module type S =
        sig
          type key
          type +'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> 'a -> 'a t -> 'a t
          val singleton : key -> 'a -> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> 'a -> unit) -> 'a t -> unit
          val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
          val for_all : (key -> 'a -> bool) -> 'a t -> bool
          val exists : (key -> 'a -> bool) -> 'a t -> bool
          val filter : (key -> 'a -> bool) -> 'a t -> 'a t
          val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('a -> 'b) -> 'a t -> 'b t
          val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
          val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
          val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
          val keys : 'a Sequence.t -> key Sequence.sequence
          val values : 'a Sequence.t -> 'a Sequence.sequence
          val to_list : 'a Sequence.t -> (key * 'a) list
          val of_list : (key * 'a) list -> 'a Sequence.t
        end
      module Adapt :
        functor (M : Map.S) ->
          sig
            type key = M.key
            type 'a t = 'a M.t
            val empty : 'a t
            val is_empty : 'a t -> bool
            val mem : key -> 'a t -> bool
            val add : key -> 'a -> 'a t -> 'a t
            val singleton : key -> 'a -> 'a t
            val remove : key -> 'a t -> 'a t
            val merge :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val union :
              (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val iter : (key -> 'a -> unit) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val for_all : (key -> 'a -> bool) -> 'a t -> bool
            val exists : (key -> 'a -> bool) -> 'a t -> bool
            val filter : (key -> 'a -> bool) -> 'a t -> 'a t
            val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
            val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
            val min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) sequence
            val of_seq : (key * 'a) sequence -> 'a t
            val keys : 'a t -> key sequence
            val values : 'a t -> 'a sequence
            val to_list : 'a t -> (key * 'a) list
            val of_list : (key * 'a) list -> 'a t
          end
      module Make :
        functor (V : Map.OrderedType) ->
          sig
            type key = V.t
            type +'a t
            val empty : 'a t
            val is_empty : 'a t -> bool
            val mem : key -> 'a t -> bool
            val add : key -> 'a -> 'a t -> 'a t
            val singleton : key -> 'a -> 'a t
            val remove : key -> 'a t -> 'a t
            val merge :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val union :
              (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val iter : (key -> 'a -> unit) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val for_all : (key -> 'a -> bool) -> 'a t -> bool
            val exists : (key -> 'a -> bool) -> 'a t -> bool
            val filter : (key -> 'a -> bool) -> 'a t -> 'a t
            val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
            val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
            val min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('a -> 'b) -> 'a t -> 'b t
            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) sequence
            val of_seq : (key * 'a) sequence -> 'a t
            val keys : 'a t -> key sequence
            val values : 'a t -> 'a sequence
            val to_list : 'a t -> (key * 'a) list
            val of_list : (key * 'a) list -> 'a t
          end
    end
  val random_int : int -> int Sequence.t
  val random_bool : bool Sequence.t
  val random_float : float -> float Sequence.t
  val random_array : 'a array -> 'a Sequence.t
  val random_list : 'a list -> 'a Sequence.t
  val shuffle : 'a Sequence.t -> 'a Sequence.t
  val shuffle_buffer : int -> 'a Sequence.t -> 'a Sequence.t
  val sample : int -> 'a Sequence.t -> 'a array
  module Infix :
    sig
      val ( -- ) : int -> int -> int Sequence.t
      val ( --^ ) : int -> int -> int Sequence.t
      val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
      val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
      val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
      val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
    end
  val ( -- ) : int -> int -> int t
  val ( --^ ) : int -> int -> int t
  val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
  val ( >|= ) : 'a t -> ('a -> 'b) -> 'b t
  val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
  val ( <+> ) : 'a t -> 'a t -> 'a t
  val pp_seq :
    ?sep:string ->
    (Format.formatter -> 'a -> unit) ->
    Format.formatter -> 'a Sequence.t -> unit
  val pp_buf :
    ?sep:string ->
    (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a Sequence.t -> unit
  val to_string : ?sep:string -> ('a -> string) -> 'a Sequence.t -> string
  module IO :
    sig
      val lines_of :
        ?mode:int ->
        ?flags:Pervasives.open_flag list -> string -> string Sequence.t
      val chunks_of :
        ?mode:int ->
        ?flags:Pervasives.open_flag list ->
        ?size:int -> string -> string Sequence.t
      val write_to :
        ?mode:int ->
        ?flags:Pervasives.open_flag list ->
        string -> string Sequence.t -> unit
      val write_bytes_to :
        ?mode:int ->
        ?flags:Pervasives.open_flag list ->
        string -> Bytes.t Sequence.t -> unit
      val write_lines :
        ?mode:int ->
        ?flags:Pervasives.open_flag list ->
        string -> string Sequence.t -> unit
      val write_bytes_lines :
        ?mode:int ->
        ?flags:Pervasives.open_flag list ->
        string -> Bytes.t Sequence.t -> unit
    end
end