sig
  module List :
    sig
      type 'a t = 'a list
      type 'a binable = 'a t
      val bin_size_t : ('a, 'a binable) Bin_prot.Size.sizer1
      val bin_write_t : ('a, 'a binable) Bin_prot.Map_to_safe.writer1
      val bin_write_t_ : ('a, 'a binable) Bin_prot.Unsafe_write_c.writer1
      val bin_read_t : ('a, 'a binable) Bin_prot.Map_to_safe.reader1
      val bin_read_t_ : ('a, 'a binable) Bin_prot.Unsafe_read_c.reader1
      val bin_read_t__ :
        ('a, int -> 'a binable) Bin_prot.Unsafe_read_c.reader1
      val bin_writer_t : ('a, 'a binable) Bin_prot.Type_class.S1.writer
      val bin_reader_t : ('a, 'a binable) Bin_prot.Type_class.S1.reader
      val bin_t : ('a, 'a binable) Bin_prot.Type_class.S1.t
      type 'a container = 'a t
      val length : 'a container -> int
      val is_empty : 'a container -> bool
      val iter : 'a container -> f:('-> unit) -> unit
      val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
      val exists : 'a container -> f:('-> bool) -> bool
      val for_all : 'a container -> f:('-> bool) -> bool
      val find : 'a container -> f:('-> bool) -> 'a option
      val to_list : 'a container -> 'a list
      val to_array : 'a container -> 'a array
      val container : ('a, 'a container) Container.type_class
      type 'a sexpable = 'a t
      val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a sexpable -> Sexplib.Sexp.t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a sexpable
      type 'a monad = 'a t
      val ( >>= ) : 'a monad -> ('-> 'b monad) -> 'b monad
      val ( >>| ) : 'a monad -> ('-> 'b) -> 'b monad
      module Monad_infix :
        sig
          type 'a monad = 'a monad
          val ( >>= ) : 'a monad -> ('-> 'b monad) -> 'b monad
          val ( >>| ) : 'a monad -> ('-> 'b) -> 'b monad
        end
      val bind : 'a monad -> ('-> 'b monad) -> 'b monad
      val return : '-> 'a monad
      val join : 'a monad monad -> 'a monad
      val ignore : 'a monad -> unit monad
      val unit : unit monad
      val nth : 'a t -> int -> 'a option
      val nth_exn : 'a t -> int -> 'a
      val rev : 'a t -> 'a t
      val rev_append : 'a t -> 'a t -> 'a t
      val rev_map : f:('-> 'b) -> 'a t -> 'b t
      val fold_left : f:('-> '-> 'a) -> init:'-> 'b t -> 'a
      val iter2 : f:('-> '-> unit) -> 'a t -> 'b t -> unit
      val rev_map2 : f:('-> '-> 'c) -> 'a t -> 'b t -> 'c t
      val fold_left2 :
        f:('-> '-> '-> 'a) -> init:'-> 'b t -> 'c t -> 'a
      val for_all2 : f:('-> '-> bool) -> 'a t -> 'b t -> bool
      val exists2 : f:('-> '-> bool) -> 'a t -> 'b t -> bool
      val mem : '-> set:'a t -> bool
      val memq : '-> set:'a t -> bool
      val filter : f:('-> bool) -> 'a t -> 'a t
      val filteri : 'a t -> f:(int -> '-> bool) -> 'a list
      val find_all : f:('-> bool) -> 'a t -> 'a t
      val partition : 'a t -> f:('-> bool) -> 'a t * 'a t
      val assoc' : ('a * 'b) t -> '-> equal:('-> '-> bool) -> 'b option
      val assoc_exn' : ('a * 'b) t -> '-> equal:('-> '-> bool) -> 'b
      val mem_assoc' : ('a * 'b) t -> '-> equal:('-> '-> bool) -> bool
      val remove_assoc' :
        ('a * 'b) t -> '-> equal:('-> '-> bool) -> ('a * 'b) t
      val assoc : '-> ('a * 'b) t -> 'b
      val mem_assoc : '-> map:('a * 'b) t -> bool
      val remove_assoc : '-> ('a * 'b) t -> ('a * 'b) t
      val sort : cmp:('-> '-> int) -> 'a t -> 'a t
      val stable_sort : cmp:('-> '-> int) -> 'a t -> 'a t
      val fast_sort : cmp:('-> '-> int) -> 'a t -> 'a t
      val merge : 'a t -> 'a t -> cmp:('-> '-> int) -> 'a t
      val hd : 'a t -> 'a option
      val tl : 'a t -> 'a t option
      val hd_exn : 'a t -> 'a
      val tl_exn : 'a t -> 'a t
      val findi : 'a t -> f:(int -> '-> bool) -> (int * 'a) option
      val find_map : 'a t -> f:('-> 'b option) -> 'b option
      val find_exn : 'a t -> f:('-> bool) -> 'a
      val append : 'a t -> 'a t -> 'a t
      val map : 'a t -> f:('-> 'b) -> 'b t
      val concat_map : 'a t -> f:('-> 'b t) -> 'b t
      val map2 : 'a t -> 'b t -> f:('-> '-> 'c) -> 'c t
      val rev_map3 : 'a t -> 'b t -> 'c t -> f:('-> '-> '-> 'd) -> 'd t
      val map3 : 'a t -> 'b t -> 'c t -> f:('-> '-> '-> 'd) -> 'd t
      val rev_map_append : 'a t -> 'b t -> f:('-> 'b) -> 'b t
      val fold_right : 'a t -> f:('-> '-> 'b) -> init:'-> 'b
      val fold_right2 :
        'a t -> 'b t -> f:('-> '-> '-> 'c) -> init:'-> 'c
      val split : ('a * 'b) t -> 'a t * 'b t
      val combine : 'a t -> 'b t -> ('a * 'b) t
      val mapi : 'a t -> f:(int -> '-> 'b) -> 'b t
      val iteri : 'a t -> f:(int -> '-> unit) -> unit
      val fold_lefti : 'a t -> f:(int -> '-> '-> 'b) -> init:'-> 'b
      val reduce_exn : 'a t -> f:('-> '-> 'a) -> 'a
      val reduce : 'a t -> f:('-> '-> 'a) -> 'a option
      val group : 'a t -> break:('-> '-> bool) -> 'a t t
      val groupi : 'a t -> break:(int -> '-> '-> bool) -> 'a t t
      val min_combine : 'a t -> 'b t -> ('a * 'b) t
      val last : 'a t -> 'a option
      val last_exn : 'a t -> 'a
      val dedup : ?compare:('-> '-> int) -> 'a t -> 'a t
      val stable_dedup : 'a t -> 'a t
      val contains_dup : 'a t -> bool
      val find_a_dup : 'a t -> 'a option
      val count : 'a t -> f:('-> bool) -> int
      val range : ?stride:int -> int -> int -> int t
      val frange : ?stride:float -> float -> float -> float t
      val init : int -> f:(int -> 'a) -> 'a t
      val rev_filter_map : 'a t -> f:('-> 'b option) -> 'b t
      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
      val filter_opt : 'a option t -> 'a t
      val partition_map :
        'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
      val reverse_pairs : ('a * 'b) t -> ('b * 'a) t
      val split_n : 'a t -> int -> 'a t * 'a t
      val sub : 'a t -> pos:int -> len:int -> 'a t
      val slice : 'a t -> int -> int -> 'a t
      val take : 'a t -> int -> 'a t
      val drop : 'a t -> int -> 'a t
      val drop_while : 'a t -> f:('-> bool) -> 'a t
      val concat : 'a t t -> 'a t
      val flatten : 'a t t -> 'a t
      val flatten_no_order : 'a t t -> 'a t
      val assoc_opt : '-> ('a * 'b) t -> 'b option
      val cons : '-> 'a t -> 'a t
      val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
      val to_string : ('-> string) -> 'a t -> string
      val permute : ?random_state:Random.State.t -> 'a t -> 'a t
      val is_sorted : 'a t -> compare:('-> '-> int) -> bool
      val compare : 'a t -> 'a t -> cmp:('-> '-> int) -> int
      module Infix : sig val ( @ ) : 'a t -> 'a t -> 'a t end
    end
  module Array :
    sig
      type 'a t = 'a array
      type 'a binable = 'a t
      val bin_size_t : ('a, 'a binable) Bin_prot.Size.sizer1
      val bin_write_t : ('a, 'a binable) Bin_prot.Map_to_safe.writer1
      val bin_write_t_ : ('a, 'a binable) Bin_prot.Unsafe_write_c.writer1
      val bin_read_t : ('a, 'a binable) Bin_prot.Map_to_safe.reader1
      val bin_read_t_ : ('a, 'a binable) Bin_prot.Unsafe_read_c.reader1
      val bin_read_t__ :
        ('a, int -> 'a binable) Bin_prot.Unsafe_read_c.reader1
      val bin_writer_t : ('a, 'a binable) Bin_prot.Type_class.S1.writer
      val bin_reader_t : ('a, 'a binable) Bin_prot.Type_class.S1.reader
      val bin_t : ('a, 'a binable) Bin_prot.Type_class.S1.t
      type 'a container = 'a t
      val length : 'a container -> int
      val is_empty : 'a container -> bool
      val iter : 'a container -> f:('-> unit) -> unit
      val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
      val exists : 'a container -> f:('-> bool) -> bool
      val for_all : 'a container -> f:('-> bool) -> bool
      val find : 'a container -> f:('-> bool) -> 'a option
      val to_list : 'a container -> 'a list
      val to_array : 'a container -> 'a array
      val container : ('a, 'a container) Container.type_class
      type 'a sexpable = 'a t
      val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a sexpable -> Sexplib.Sexp.t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a sexpable
      external get : 'a t -> int -> 'a = "%array_safe_get"
      external set : 'a t -> int -> '-> unit = "%array_safe_set"
      external unsafe_get : 'a t -> int -> 'a = "%array_unsafe_get"
      external unsafe_set : 'a t -> int -> '-> unit = "%array_unsafe_set"
      val create : int -> '-> 'a t
      val init : int -> f:(int -> 'a) -> 'a t
      val make_matrix : dimx:int -> dimy:int -> '-> 'a t t
      val append : 'a t -> 'a t -> 'a t
      val concat : 'a t list -> 'a t
      val sub : 'a t -> pos:int -> len:int -> 'a t
      val copy : 'a t -> 'a t
      val fill : 'a t -> pos:int -> len:int -> '-> unit
      val blit :
        src:'a t -> src_pos:int -> dst:'a t -> dst_pos:int -> len:int -> unit
      val of_list : 'a list -> 'a t
      val map : f:('-> 'b) -> 'a t -> 'b t
      val iteri : f:(int -> '-> unit) -> 'a t -> unit
      val mapi : f:(int -> '-> 'b) -> 'a t -> 'b t
      val fold_left : f:('-> '-> 'a) -> init:'-> 'b t -> 'a
      val fold_right : f:('-> '-> 'b) -> 'a t -> init:'-> 'b
      val sort : cmp:('-> '-> int) -> 'a t -> unit
      val stable_sort : cmp:('-> '-> int) -> 'a t -> unit
      val fast_sort : cmp:('-> '-> int) -> 'a t -> unit
      val max_length : int
      val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
      val normalize : 'a t -> int -> int
      val slice : 'a t -> int -> int -> 'a t
      val nget : 'a t -> int -> 'a
      val nset : 'a t -> int -> '-> unit
      val filter_opt : 'a option t -> 'a t
      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
      val filter_mapi : 'a t -> f:(int -> '-> 'b option) -> 'b t
      val map2 : 'a t -> 'b t -> f:('-> '-> 'c) -> 'c t
      val filter : f:('-> bool) -> 'a t -> 'a t
      val filteri : f:(int -> '-> bool) -> 'a t -> 'a t
      val swap : 'a t -> int -> int -> unit
      val mem : '-> 'a t -> bool
      val rev : 'a t -> unit
      val of_list_rev : 'a list -> 'a t
      val replace : 'a t -> int -> f:('-> 'a) -> unit
      val replace_all : 'a t -> f:('-> 'a) -> unit
      val find_exn : 'a t -> f:('-> bool) -> 'a
      val findi : 'a t -> f:('-> bool) -> int option
      val findi_exn : 'a t -> f:('-> bool) -> int
      val reduce : 'a t -> f:('-> '-> 'a) -> 'a option
      val reduce_exn : 'a t -> f:('-> '-> 'a) -> 'a
      val permute : ?random_state:Random.State.t -> 'a t -> unit
      val combine : 'a t -> 'b t -> ('a * 'b) t
      val split : ('a * 'b) t -> 'a t * 'b t
      val sorted_copy : 'a t -> cmp:('-> '-> int) -> 'a t
      val last : 'a t -> 'a
      val empty : unit -> 'a t
      module Infix : sig val ( <|> ) : 'a t -> int * int -> 'a t end
    end
  module type Key = Hashtbl.HashedType
  module type S =
    sig
      module Key : Key
      type 'a t
      type 'a container = 'a t
      val length : 'a container -> int
      val is_empty : 'a container -> bool
      val iter : 'a container -> f:('-> unit) -> unit
      val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
      val exists : 'a container -> f:('-> bool) -> bool
      val for_all : 'a container -> f:('-> bool) -> bool
      val find : 'a container -> f:('-> bool) -> 'a option
      val to_list : 'a container -> 'a list
      val to_array : 'a container -> 'a array
      val container : ('a, 'a container) Container.type_class
      val invariant : 'a t -> unit
      val create : unit -> 'a t
      val clear : 'a t -> unit
      val mem : 'a t -> Key.t -> bool
      val lookup : 'a t -> Key.t -> 'a option
      val lookup_exn : 'a t -> Key.t -> 'a
      val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
      val enqueue_exn : 'a t -> Key.t -> '-> unit
      val dequeue : 'a t -> 'a option
      val dequeue_exn : 'a t -> 'a
      val dequeue_with_key : 'a t -> (Key.t * 'a) option
      val dequeue_with_key_exn : 'a t -> Key.t * 'a
      val dequeue_all : 'a t -> f:('-> unit) -> unit
      val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
      val remove_exn : 'a t -> Key.t -> unit
      val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
      val replace_exn : 'a t -> Key.t -> '-> unit
      val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
      val foldi :
        'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
    end
  module Make :
    functor (Key : Key->
      sig
        module Key :
          sig
            type t = Key.t
            val equal : t -> t -> bool
            val hash : t -> int
            type sexpable = t
            val sexp_of_t : sexpable -> Sexplib.Sexp.t
            val t_of_sexp : Sexplib.Sexp.t -> sexpable
          end
        type 'a t = 'Hash_queue.Make(Key).t
        type 'a container = 'a t
        val length : 'a container -> int
        val is_empty : 'a container -> bool
        val iter : 'a container -> f:('-> unit) -> unit
        val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
        val exists : 'a container -> f:('-> bool) -> bool
        val for_all : 'a container -> f:('-> bool) -> bool
        val find : 'a container -> f:('-> bool) -> 'a option
        val to_list : 'a container -> 'a list
        val to_array : 'a container -> 'a array
        val container : ('a, 'a container) Container.type_class
        val invariant : 'a t -> unit
        val create : unit -> 'a t
        val clear : 'a t -> unit
        val mem : 'a t -> Key.t -> bool
        val lookup : 'a t -> Key.t -> 'a option
        val lookup_exn : 'a t -> Key.t -> 'a
        val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
        val enqueue_exn : 'a t -> Key.t -> '-> unit
        val dequeue : 'a t -> 'a option
        val dequeue_exn : 'a t -> 'a
        val dequeue_with_key : 'a t -> (Key.t * 'a) option
        val dequeue_with_key_exn : 'a t -> Key.t * 'a
        val dequeue_all : 'a t -> f:('-> unit) -> unit
        val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
        val remove_exn : 'a t -> Key.t -> unit
        val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
        val replace_exn : 'a t -> Key.t -> '-> unit
        val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
        val foldi :
          'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
      end
end