sig
  module Hashtbl :
    sig
      type ('a, 'b) t = ('a, 'b) Hashtbl.t
      val create : int -> ('a, 'b) t
      val length : ('a, 'b) t -> int
      val is_empty : ('a, 'b) t -> bool
      val add : ('a, 'b) t -> '-> '-> unit
      val remove : ('a, 'b) t -> '-> unit
      val remove_all : ('a, 'b) t -> '-> unit
      val replace : ('a, 'b) t -> '-> '-> unit
      val copy : ('a, 'b) t -> ('a, 'b) t
      val clear : ('a, 'b) t -> unit
      val keys : ('a, 'b) t -> 'BatEnum.t
      val values : ('a, 'b) t -> 'BatEnum.t
      val enum : ('a, 'b) t -> ('a * 'b) BatEnum.t
      val of_enum : ('a * 'b) BatEnum.t -> ('a, 'b) t
      val find : ('a, 'b) t -> '-> 'b
      val find_all : ('a, 'b) t -> '-> 'b list
      val find_default : ('a, 'b) t -> '-> '-> 'b
      val find_option : ('a, 'b) Hashtbl.t -> '-> 'b option
      val mem : ('a, 'b) t -> '-> bool
      val iter : ('-> '-> unit) -> ('a, 'b) t -> unit
      val fold : ('-> '-> '-> 'c) -> ('a, 'b) t -> '-> 'c
      val map : ('-> '-> 'c) -> ('a, 'b) t -> ('a, 'c) t
      val filter : ('-> bool) -> ('key, 'a) t -> ('key, 'a) t
      val filteri : ('key -> '-> bool) -> ('key, 'a) t -> ('key, 'a) t
      val filter_map :
        ('key -> '-> 'b option) -> ('key, 'a) t -> ('key, 'b) t
      val hash : '-> int
      external hash_param : int -> int -> '-> int = "caml_hash_univ_param"
        "noalloc"
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ?kvsep:string ->
        ('BatInnerIO.output -> '-> unit) ->
        ('BatInnerIO.output -> '-> unit) ->
        'BatInnerIO.output -> ('b, 'c) t -> unit
      module Exceptionless : sig val find : ('a, 'b) t -> '-> 'b option end
      module Infix :
        sig
          val ( --> ) : ('a, 'b) t -> '-> 'b
          val ( <-- ) : ('a, 'b) t -> 'a * '-> unit
        end
      module Labels :
        sig
          val add : ('a, 'b) t -> key:'-> data:'-> unit
          val replace : ('a, 'b) t -> key:'-> data:'-> unit
          val iter : f:(key:'-> data:'-> unit) -> ('a, 'b) t -> unit
          val map : f:(key:'-> data:'-> 'c) -> ('a, 'b) t -> ('a, 'c) t
          val filter : f:('-> bool) -> ('key, 'a) t -> ('key, 'a) t
          val filteri :
            f:(key:'key -> data:'-> bool) -> ('key, 'a) t -> ('key, 'a) t
          val filter_map :
            f:(key:'key -> data:'-> 'b option) ->
            ('key, 'a) t -> ('key, 'b) t
          val fold :
            f:(key:'-> data:'-> '-> 'c) -> ('a, 'b) t -> init:'-> 'c
        end
      module type HashedType =
        sig type t val equal : t -> t -> bool val hash : t -> int end
      module type S =
        sig
          type key
          type 'a t
          val create : int -> 'a t
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val clear : 'a t -> unit
          val copy : 'a t -> 'a t
          val add : 'a t -> key -> '-> unit
          val remove : 'a t -> key -> unit
          val remove_all : 'a t -> key -> unit
          val find : 'a t -> key -> 'a
          val find_all : 'a t -> key -> 'a list
          val find_default : 'a t -> key -> '-> 'a
          val find_option : 'a t -> key -> 'a option
          val replace : 'a t -> key -> '-> unit
          val mem : 'a t -> key -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val map : (key -> '-> 'c) -> 'b t -> 'c t
          val filter : ('-> bool) -> 'a t -> 'a t
          val filteri : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val keys : 'a t -> key BatEnum.t
          val values : 'a t -> 'BatEnum.t
          val enum : 'a t -> (key * 'a) BatEnum.t
          val of_enum : (key * 'a) BatEnum.t -> 'a t
          val print :
            ?first:string ->
            ?last:string ->
            ?sep:string ->
            ('BatInnerIO.output -> key -> unit) ->
            ('BatInnerIO.output -> '-> unit) ->
            'BatInnerIO.output -> 'b t -> unit
          module Exceptionless : sig val find : 'a t -> key -> 'a option end
          module Infix :
            sig
              val ( --> ) : 'a t -> key -> 'a
              val ( <-- ) : 'a t -> key * '-> unit
            end
          module Labels :
            sig
              val add : 'a t -> key:key -> data:'-> unit
              val replace : 'a t -> key:key -> data:'-> unit
              val iter : f:(key:key -> data:'-> unit) -> 'a t -> unit
              val map : f:(key:key -> data:'-> 'b) -> 'a t -> 'b t
              val filter : f:('-> bool) -> 'a t -> 'a t
              val filteri : f:(key:key -> data:'-> bool) -> 'a t -> 'a t
              val filter_map :
                f:(key:key -> data:'-> 'b option) -> 'a t -> 'b t
              val fold :
                f:(key:key -> data:'-> '-> 'b) -> 'a t -> init:'-> 'b
            end
        end
      module Make :
        functor (H : HashedType->
          sig
            type key = H.t
            type 'a t = 'BatHashtbl.Make(H).t
            val create : int -> 'a t
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val clear : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> '-> unit
            val remove : 'a t -> key -> unit
            val remove_all : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_all : 'a t -> key -> 'a list
            val find_default : 'a t -> key -> '-> 'a
            val find_option : 'a t -> key -> 'a option
            val replace : 'a t -> key -> '-> unit
            val mem : 'a t -> key -> bool
            val iter : (key -> '-> unit) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val map : (key -> '-> 'c) -> 'b t -> 'c t
            val filter : ('-> bool) -> 'a t -> 'a t
            val filteri : (key -> '-> bool) -> 'a t -> 'a t
            val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
            val keys : 'a t -> key BatEnum.t
            val values : 'a t -> 'BatEnum.t
            val enum : 'a t -> (key * 'a) BatEnum.t
            val of_enum : (key * 'a) BatEnum.t -> 'a t
            val print :
              ?first:string ->
              ?last:string ->
              ?sep:string ->
              ('BatInnerIO.output -> key -> unit) ->
              ('BatInnerIO.output -> '-> unit) ->
              'BatInnerIO.output -> 'b t -> unit
            module Exceptionless :
              sig val find : 'a t -> key -> 'a option end
            module Infix :
              sig
                val ( --> ) : 'a t -> key -> 'a
                val ( <-- ) : 'a t -> key * '-> unit
              end
            module Labels :
              sig
                val add : 'a t -> key:key -> data:'-> unit
                val replace : 'a t -> key:key -> data:'-> unit
                val iter : f:(key:key -> data:'-> unit) -> 'a t -> unit
                val map : f:(key:key -> data:'-> 'b) -> 'a t -> 'b t
                val filter : f:('-> bool) -> 'a t -> 'a t
                val filteri : f:(key:key -> data:'-> bool) -> 'a t -> 'a t
                val filter_map :
                  f:(key:key -> data:'-> 'b option) -> 'a t -> 'b t
                val fold :
                  f:(key:key -> data:'-> '-> 'b) -> 'a t -> init:'-> 'b
              end
          end
      module Cap :
        sig
          type ('a, 'b, 'c) t = ('a, 'b, 'c) BatHashtbl.Cap.t
            constraint 'c = [< `Read | `Write ]
          val create : int -> ('a, 'b, [< `Read | `Write ]) t
          external of_table :
            ('a, 'b) Hashtbl.t -> ('a, 'b, [< `Read | `Write ]) t
            = "%identity"
          external to_table :
            ('a, 'b, [ `Read | `Write ]) t -> ('a, 'b) Hashtbl.t
            = "%identity"
          external read_only :
            ('a, 'b, [< `Read | `Write > `Read ]) t -> ('a, 'b, [ `Read ]) t
            = "%identity"
          external write_only :
            ('a, 'b, [< `Read | `Write > `Write ]) t ->
            ('a, 'b, [ `Write ]) t = "%identity"
          val length : ('a, 'b, [< `Read | `Write ]) t -> int
          val is_empty : ('a, 'b, [< `Read | `Write ]) t -> bool
          val add :
            ('a, 'b, [< `Read | `Write > `Write ]) t -> '-> '-> unit
          val remove : ('a, 'b, [< `Read | `Write > `Write ]) t -> '-> unit
          val remove_all :
            ('a, 'b, [< `Read | `Write > `Write ]) t -> '-> unit
          val replace :
            ('a, 'b, [< `Read | `Write > `Write ]) t -> '-> '-> unit
          val copy :
            ('a, 'b, [< `Read | `Write > `Read ]) t ->
            ('a, 'b, [< `Read | `Write ]) t
          val clear : ('a, 'b, [< `Read | `Write > `Write ]) t -> unit
          val find : ('a, 'b, [< `Read | `Write > `Read ]) t -> '-> 'b
          val find_all :
            ('a, 'b, [< `Read | `Write > `Read ]) t -> '-> 'b list
          val find_default :
            ('a, 'b, [< `Read | `Write > `Read ]) t -> '-> '-> 'b
          val find_option :
            ('a, 'b, [< `Read | `Write > `Read ]) t -> '-> 'b option
          val mem : ('a, 'b, [< `Read | `Write > `Read ]) t -> '-> bool
          val iter :
            ('-> '-> unit) ->
            ('a, 'b, [< `Read | `Write > `Read ]) t -> unit
          val fold :
            ('-> '-> '-> 'c) ->
            ('a, 'b, [< `Read | `Write > `Read ]) t -> '-> 'c
          val map :
            ('-> '-> 'c) ->
            ('a, 'b, [< `Read | `Write > `Read ]) t ->
            ('a, 'c, [< `Read | `Write ]) t
          val filter :
            ('-> bool) ->
            ('key, 'a, [< `Read | `Write > `Read ]) t ->
            ('key, 'a, [< `Read | `Write ]) t
          val filteri :
            ('key -> '-> bool) ->
            ('key, 'a, [< `Read | `Write > `Read ]) t ->
            ('key, 'a, [< `Read | `Write ]) t
          val filter_map :
            ('key -> '-> 'b option) ->
            ('key, 'a, [< `Read | `Write > `Read ]) t ->
            ('key, 'b, [< `Read | `Write ]) t
          val keys : ('a, 'b, [< `Read | `Write > `Read ]) t -> 'BatEnum.t
          val values :
            ('a, 'b, [< `Read | `Write > `Read ]) t -> 'BatEnum.t
          val enum :
            ('a, 'b, [< `Read | `Write > `Read ]) t -> ('a * 'b) BatEnum.t
          val of_enum :
            ('a * 'b) BatEnum.t -> ('a, 'b, [< `Read | `Write ]) t
          val print :
            ?first:string ->
            ?last:string ->
            ?sep:string ->
            ?kvsep:string ->
            ('BatInnerIO.output -> '-> unit) ->
            ('BatInnerIO.output -> '-> unit) ->
            'BatInnerIO.output ->
            ('b, 'c, [< `Read | `Write > `Read ]) t -> unit
          module Exceptionless :
            sig
              val find :
                ('a, 'b, [< `Read | `Write > `Read ]) t -> '-> 'b option
            end
          module Labels :
            sig
              val add :
                ('a, 'b, [< `Read | `Write > `Write ]) t ->
                key:'-> data:'-> unit
              val replace :
                ('a, 'b, [< `Read | `Write > `Write ]) t ->
                key:'-> data:'-> unit
              val iter :
                f:(key:'-> data:'-> unit) ->
                ('a, 'b, [< `Read | `Write > `Read ]) t -> unit
              val map :
                f:(key:'-> data:'-> 'c) ->
                ('a, 'b, [< `Read | `Write > `Read ]) t ->
                ('a, 'c, [< `Read | `Write ]) t
              val filter :
                f:('-> bool) ->
                ('key, 'a, [< `Read | `Write > `Read ]) t ->
                ('key, 'a, [< `Read | `Write ]) t
              val filteri :
                f:(key:'key -> data:'-> bool) ->
                ('key, 'a, [< `Read | `Write > `Read ]) t ->
                ('key, 'a, [< `Read | `Write ]) t
              val filter_map :
                f:(key:'key -> data:'-> 'b option) ->
                ('key, 'a, [< `Read | `Write > `Read ]) t ->
                ('key, 'b, [< `Read | `Write ]) t
              val fold :
                f:(key:'-> data:'-> '-> 'c) ->
                ('a, 'b, [< `Read | `Write > `Read ]) t -> init:'-> 'c
            end
        end
    end
end