sig
  module Make :
    functor (U : sig  end) ->
      sig
        type name
        type t = Identifier.Make.name
        val register : string -> Identifier.Make.name
        val print : Identifier.Make.name -> string
        val equal : Identifier.Make.name -> Identifier.Make.name -> bool
        val compare : Identifier.Make.name -> Identifier.Make.name -> int
        val hash : Identifier.Make.name -> int
        module Map :
          sig
            type key = name
            type 'a t
            val empty : 'a t
            val lookup : key -> 'a t -> 'a
            val find : key -> 'a t -> 'a
            val add : key -> 'a -> 'a t -> 'a t
            exception Unchanged
            val strict_add : key -> 'a -> 'a t -> 'a t
            type 'a decision = 'a -> 'a -> 'a
            val fine_add : 'a decision -> key -> 'a -> 'a t -> 'a t
            val mem : key -> 'a t -> bool
            val singleton : key -> 'a -> 'a t
            val is_empty : 'a t -> bool
            val is_singleton : 'a t -> (key * 'a) option
            val cardinal : 'a t -> int
            val choose : 'a t -> key * 'a
            val lookup_and_remove : key -> 'a t -> 'a * 'a t
            val find_and_remove : key -> 'a t -> 'a * 'a t
            val remove : key -> 'a t -> 'a t
            val union : 'a t -> 'a t -> 'a t
            val fine_union : 'a decision -> 'a t -> 'a t -> 'a t
            val iter : (key -> 'a -> unit) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val fold_rev : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val iter2 : (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
            val map : ('a -> 'b) -> 'a t -> 'b t
            val endo_map : ('a -> 'a) -> 'a t -> 'a t
            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            module Domain :
              sig
                type element = key
                type t
                val empty : t
                val is_empty : t -> bool
                val singleton : element -> t
                val cardinal : t -> int
                val choose : t -> element
                val mem : element -> t -> bool
                val add : element -> t -> t
                val remove : element -> t -> t
                val union : t -> t -> t
                val diff : t -> t -> t
                val inter : t -> t -> t
                val disjoint : t -> t -> bool
                val iter : (element -> unit) -> t -> unit
                val fold : (element -> 'b -> 'b) -> t -> 'b -> 'b
                val elements : t -> element list
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
              end
            val domain : 'a t -> Domain.t
            val lift : (key -> 'a) -> Domain.t -> 'a t
            val corestrict : 'a t -> Domain.t -> 'a t
          end
        val memoize :
          (Identifier.Make.name -> 'a) -> Identifier.Make.name -> 'a
      end
end