sig
  module type S = sig type t val get_hash : GenericMap.S.t -> int end
  module type GenericMapSig =
    sig
      type key
      type 'a t
      val empty : 'a GenericMap.GenericMapSig.t
      val is_empty : 'a GenericMap.GenericMapSig.t -> bool
      val add :
        GenericMap.GenericMapSig.key ->
        'a -> 'a GenericMap.GenericMapSig.t -> 'a GenericMap.GenericMapSig.t
      val cardinal : 'a GenericMap.GenericMapSig.t -> int
      val modify :
        GenericMap.GenericMapSig.key ->
        ('a option -> 'a) ->
        'a GenericMap.GenericMapSig.t -> 'a GenericMap.GenericMapSig.t
      val find :
        GenericMap.GenericMapSig.key -> 'a GenericMap.GenericMapSig.t -> 'a
      val remove :
        GenericMap.GenericMapSig.key ->
        'a GenericMap.GenericMapSig.t -> 'a GenericMap.GenericMapSig.t
      val mem :
        GenericMap.GenericMapSig.key -> 'a GenericMap.GenericMapSig.t -> bool
      val iter :
        (GenericMap.GenericMapSig.key -> 'a -> unit) ->
        'a GenericMap.GenericMapSig.t -> unit
      val map :
        ('a -> 'b) ->
        'a GenericMap.GenericMapSig.t -> 'b GenericMap.GenericMapSig.t
      val mapi :
        (GenericMap.GenericMapSig.key -> 'a -> 'b) ->
        'a GenericMap.GenericMapSig.t -> 'b GenericMap.GenericMapSig.t
      val fold :
        (GenericMap.GenericMapSig.key -> 'a -> 'b -> 'b) ->
        'a GenericMap.GenericMapSig.t -> 'b -> 'b
      val compare :
        ('a -> 'a -> int) ->
        'a GenericMap.GenericMapSig.t -> 'a GenericMap.GenericMapSig.t -> int
      val equal :
        ('a -> 'a -> bool) ->
        'a GenericMap.GenericMapSig.t ->
        'a GenericMap.GenericMapSig.t -> bool
      val merge :
        ('a -> 'a -> 'a) ->
        'a GenericMap.GenericMapSig.t ->
        'a GenericMap.GenericMapSig.t -> 'a GenericMap.GenericMapSig.t
      val choose_and_remove :
        'a GenericMap.GenericMapSig.t ->
        GenericMap.GenericMapSig.key * 'a * 'a GenericMap.GenericMapSig.t
      val filter :
        ('a -> bool) ->
        'a GenericMap.GenericMapSig.t -> 'a GenericMap.GenericMapSig.t
      val filteri :
        (GenericMap.GenericMapSig.key -> 'a -> bool) ->
        'a GenericMap.GenericMapSig.t -> 'a GenericMap.GenericMapSig.t
      val key_elements :
        'a GenericMap.GenericMapSig.t -> GenericMap.GenericMapSig.key list
      val value_elements : 'a GenericMap.GenericMapSig.t -> 'a list
      val elements :
        'a GenericMap.GenericMapSig.t ->
        (GenericMap.GenericMapSig.key * 'a) list
      val subset :
        ('a -> 'a -> bool) ->
        'a GenericMap.GenericMapSig.t ->
        'a GenericMap.GenericMapSig.t -> bool
    end
  module Make :
    functor (El : S) ->
      sig
        type key = El.t
        type 'a t
        val empty : 'a t
        val is_empty : 'a t -> bool
        val add : key -> 'a -> 'a t -> 'a t
        val cardinal : 'a t -> int
        val modify : key -> ('a option -> 'a) -> 'a t -> 'a t
        val find : key -> 'a t -> 'a
        val remove : key -> 'a t -> 'a t
        val mem : key -> 'a t -> bool
        val iter : (key -> 'a -> unit) -> 'a t -> unit
        val map : ('a -> 'b) -> 'a t -> 'b t
        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
        val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
        val merge : ('a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
        val choose_and_remove : 'a t -> key * 'a * 'a t
        val filter : ('a -> bool) -> 'a t -> 'a t
        val filteri : (key -> 'a -> bool) -> 'a t -> 'a t
        val key_elements : 'a t -> key list
        val value_elements : 'a t -> 'a list
        val elements : 'a t -> (key * 'a) list
        val subset : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      end
  module MaptoSet :
    functor
      (S : sig type t end) (GMap : sig
                                     type key = S.t
                                     type 'a t
                                     val empty : 'a t
                                     val is_empty : 'a t -> bool
                                     val add : key -> 'a -> 'a t -> 'a t
                                     val cardinal : 'a t -> int
                                     val modify :
                                       key ->
                                       ('a option -> 'a) -> 'a t -> 'a t
                                     val find : key -> 'a t -> 'a
                                     val remove : key -> 'a t -> 'a t
                                     val mem : key -> 'a t -> bool
                                     val iter :
                                       (key -> 'a -> unit) -> 'a t -> unit
                                     val map : ('a -> 'b) -> 'a t -> 'b t
                                     val mapi :
                                       (key -> 'a -> 'b) -> 'a t -> 'b t
                                     val fold :
                                       (key -> 'a -> 'b -> 'b) ->
                                       'a t -> 'b -> 'b
                                     val compare :
                                       ('a -> 'a -> int) ->
                                       'a t -> 'a t -> int
                                     val equal :
                                       ('a -> 'a -> bool) ->
                                       'a t -> 'a t -> bool
                                     val merge :
                                       ('a -> 'a -> 'a) ->
                                       'a t -> 'a t -> 'a t
                                     val choose_and_remove :
                                       'a t -> key * 'a * 'a t
                                     val filter :
                                       ('a -> bool) -> 'a t -> 'a t
                                     val filteri :
                                       (key -> 'a -> bool) -> 'a t -> 'a t
                                     val key_elements : 'a t -> key list
                                     val value_elements : 'a t -> 'a list
                                     val elements : 'a t -> (key * 'a) list
                                     val subset :
                                       ('a -> 'a -> bool) ->
                                       'a t -> 'a t -> bool
                                   end) (GSet : sig
                                                  type t
                                                  type elt = S.t
                                                  val empty : t
                                                  val is_empty : t -> bool
                                                  val singleton : elt -> t
                                                  val mem : elt -> t -> bool
                                                  val add : elt -> t -> t
                                                  val remove : elt -> t -> t
                                                  val union : t -> t -> t
                                                  val diff : t -> t -> t
                                                  val equal : t -> t -> bool
                                                  val elements :
                                                    t -> elt list
                                                  val cardinal : t -> int
                                                  val iter :
                                                    (elt -> unit) ->
                                                    t -> unit
                                                  val fold :
                                                    (elt -> 'b -> 'b) ->
                                                    t -> 'b -> 'b
                                                  val exists :
                                                    (elt -> bool) ->
                                                    t -> bool
                                                  val filter :
                                                    (elt -> bool) -> t -> t
                                                  val inter : t -> t -> t
                                                  val of_list : elt list -> t
                                                  val of_array :
                                                    elt array -> t
                                                  val subset : t -> t -> bool
                                                end) ->
      sig val to_set : 'a GMap.t -> GSet.t end
end