sig
  type ('a, 'b) hash_consed = private {
    hkey : int;
    tag : int;
    node : 'a;
    prop : 'b;
  }
  val compare :
    ('a, 'b) Hashcons.hash_consed -> ('a, 'b) Hashcons.hash_consed -> int
  val equal :
    ('a, 'b) Hashcons.hash_consed -> ('a, 'b) Hashcons.hash_consed -> bool
  val hash : ('a, 'b) Hashcons.hash_consed -> int
  type ('a, 'b) t
  val create : int -> ('a, 'b) Hashcons.t
  val clear : ('a, 'b) Hashcons.t -> unit
  val hashcons :
    ('a, 'b) Hashcons.t -> '-> '-> ('a, 'b) Hashcons.hash_consed
  val iter :
    (('a, 'b) Hashcons.hash_consed -> unit) -> ('a, 'b) Hashcons.t -> unit
  val fold :
    (('a, 'b) Hashcons.hash_consed -> '-> 'c) ->
    ('a, 'b) Hashcons.t -> '-> 'c
  val stats : ('a, 'b) Hashcons.t -> int * int * int * int * int * int
  module type HashedType =
    sig
      type t
      type prop
      val equal : Hashcons.HashedType.t -> Hashcons.HashedType.t -> bool
      val hash : Hashcons.HashedType.t -> int
    end
  module type S =
    sig
      type key
      type prop
      type t
      val create : int -> Hashcons.S.t
      val clear : Hashcons.S.t -> unit
      val hashcons :
        Hashcons.S.t ->
        Hashcons.S.key ->
        Hashcons.S.prop ->
        (Hashcons.S.key, Hashcons.S.prop) Hashcons.hash_consed
      val find :
        Hashcons.S.t ->
        Hashcons.S.key ->
        (Hashcons.S.key, Hashcons.S.prop) Hashcons.hash_consed
      val iter :
        ((Hashcons.S.key, Hashcons.S.prop) Hashcons.hash_consed -> unit) ->
        Hashcons.S.t -> unit
      val fold :
        ((Hashcons.S.key, Hashcons.S.prop) Hashcons.hash_consed -> '-> 'a) ->
        Hashcons.S.t -> '-> 'a
      val stats : Hashcons.S.t -> int * int * int * int * int * int
    end
  module Make :
    functor (H : HashedType->
      sig
        type key = H.t
        type prop = H.prop
        type t
        val create : int -> t
        val clear : t -> unit
        val hashcons : t -> key -> prop -> (key, prop) hash_consed
        val find : t -> key -> (key, prop) hash_consed
        val iter : ((key, prop) hash_consed -> unit) -> t -> unit
        val fold : ((key, prop) hash_consed -> '-> 'a) -> t -> '-> 'a
        val stats : t -> int * int * int * int * int * int
      end
end