functor (K : Key->
  functor
    (Top_Param : sig
                   module O :
                     sig
                       type elt = K.t
                       type t
                       val empty : t
                       val is_empty : t -> bool
                       val mem : elt -> t -> bool
                       val add : elt -> t -> t
                       val singleton : elt -> t
                       val remove : elt -> t -> t
                       val union : t -> t -> t
                       val inter : t -> t -> t
                       val diff : t -> t -> t
                       val subset : t -> t -> bool
                       val iter : (elt -> unit) -> t -> unit
                       val fold : (elt -> '-> 'a) -> t -> '-> 'a
                       val for_all : (elt -> bool) -> t -> bool
                       val exists : (elt -> bool) -> t -> bool
                       val filter : (elt -> bool) -> t -> t
                       val partition : (elt -> bool) -> t -> t * t
                       val cardinal : t -> int
                       val elements : t -> elt list
                       val choose : t -> elt
                       val split : elt -> t -> t * bool * t
                       val find : elt -> t -> elt
                       val of_list : elt list -> t
                       val ty : t Type.t
                       val name : string
                       val descr : t Descr.t
                       val packed_descr : Structural_descr.pack
                       val reprs : t list
                       val equal : t -> t -> bool
                       val compare : t -> t -> int
                       val hash : t -> int
                       val pretty_code : Format.formatter -> t -> unit
                       val internal_pretty_code :
                         Type.precedence -> Format.formatter -> t -> unit
                       val pretty : Format.formatter -> t -> unit
                       val varname : t -> string
                       val mem_project :
                         (Project_skeleton.t -> bool) -> t -> bool
                       val copy : t -> t
                     end
                   exception Error_Top
                   type t = private Set of O.t | Top
                   val ty : t Type.t
                   val name : string
                   val descr : t Descr.t
                   val packed_descr : Structural_descr.pack
                   val reprs : t list
                   val equal : t -> t -> bool
                   val compare : t -> t -> int
                   val hash : t -> int
                   val pretty_code : Format.formatter -> t -> unit
                   val internal_pretty_code :
                     Type.precedence -> Format.formatter -> t -> unit
                   val pretty : Format.formatter -> t -> unit
                   val varname : t -> string
                   val mem_project :
                     (Project_skeleton.t -> bool) -> t -> bool
                   val copy : t -> t
                   val join : t -> t -> t
                   val is_included : t -> t -> bool
                   val join_and_is_included : t -> t -> t * bool
                   val bottom : t
                   val top : t
                   type widen_hint = O.t
                   val widen : widen_hint -> t -> t -> t
                   val cardinal_zero_or_one : t -> bool
                   val narrow : t -> t -> t
                   val link : t -> t -> t
                   val meet : t -> t -> t
                   val intersects : t -> t -> bool
                   val inject_singleton : O.elt -> t
                   val inject : O.t -> t
                   val empty : t
                   val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
                   val apply1 : (O.elt -> O.elt) -> t -> t
                   val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
                   val iter : (O.elt -> unit) -> t -> unit
                   val exists : (O.elt -> bool) -> t -> bool
                   val for_all : (O.elt -> bool) -> t -> bool
                   val project : t -> O.t
                   val mem : O.elt -> t -> bool
                 end->
    functor (V : Lattice_type.Full_AI_Lattice_with_cardinality->
      functor
        (Comp : sig
                  val e : bool
                  val f : K.t -> V.t -> bool
                  val compose : bool -> bool -> bool
                  val default : bool
                end->
        functor (L : sig val v : (K.t * V.t) list list end->
          functor
            (Null_Behavior : sig
                               val null : K.t
                               val is_null : K.t -> bool
                               val zone : bool
                             end->
            sig
              module M :
                sig
                  type key = K.t
                  type t =
                      Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.t
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                  module Set :
                    sig
                      type elt = t
                      type t =
                          Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.Set.t
                      val empty : t
                      val is_empty : t -> bool
                      val mem : elt -> t -> bool
                      val add : elt -> t -> t
                      val singleton : elt -> t
                      val remove : elt -> t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val subset : t -> t -> bool
                      val iter : (elt -> unit) -> t -> unit
                      val fold : (elt -> '-> 'a) -> t -> '-> 'a
                      val for_all : (elt -> bool) -> t -> bool
                      val exists : (elt -> bool) -> t -> bool
                      val filter : (elt -> bool) -> t -> t
                      val partition : (elt -> bool) -> t -> t * t
                      val cardinal : t -> int
                      val elements : t -> elt list
                      val choose : t -> elt
                      val split : elt -> t -> t * bool * t
                      val find : elt -> t -> elt
                      val of_list : elt list -> t
                      val min_elt : t -> elt
                      val max_elt : t -> elt
                      val nearest_elt_le : elt -> t -> elt
                      val nearest_elt_ge : elt -> t -> elt
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
                  module Map :
                    sig
                      type key = t
                      type 'a t =
                          'a
                          Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.Map.t
                      val empty : 'a t
                      val is_empty : 'a t -> bool
                      val mem : key -> 'a t -> bool
                      val add : key -> '-> 'a t -> 'a t
                      val singleton : key -> '-> 'a t
                      val remove : key -> 'a t -> 'a t
                      val merge :
                        (key -> 'a option -> 'b option -> 'c option) ->
                        'a t -> 'b t -> 'c t
                      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val for_all : (key -> '-> bool) -> 'a t -> bool
                      val exists : (key -> '-> bool) -> 'a t -> bool
                      val filter : (key -> '-> bool) -> 'a t -> 'a t
                      val partition :
                        (key -> '-> bool) -> 'a t -> 'a t * 'a t
                      val cardinal : 'a t -> int
                      val bindings : 'a t -> (key * 'a) list
                      val min_binding : 'a t -> key * 'a
                      val max_binding : 'a t -> key * 'a
                      val choose : 'a t -> key * 'a
                      val split : key -> 'a t -> 'a t * 'a option * 'a t
                      val find : key -> 'a t -> 'a
                      val map : ('-> 'b) -> 'a t -> 'b t
                      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                      module Key :
                        sig
                          type t = key
                          val ty : t Type.t
                          val name : string
                          val descr : t Descr.t
                          val packed_descr : Structural_descr.pack
                          val reprs : t list
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          val hash : t -> int
                          val pretty_code : Format.formatter -> t -> unit
                          val internal_pretty_code :
                            Type.precedence -> Format.formatter -> t -> unit
                          val pretty : Format.formatter -> t -> unit
                          val varname : t -> string
                          val mem_project :
                            (Project_skeleton.t -> bool) -> t -> bool
                          val copy : t -> t
                        end
                      module Make :
                        functor (Data : Datatype.S->
                          sig
                            type t = Data.t t
                            val ty : t Type.t
                            val name : string
                            val descr : t Descr.t
                            val packed_descr : Structural_descr.pack
                            val reprs : t list
                            val equal : t -> t -> bool
                            val compare : t -> t -> int
                            val hash : t -> int
                            val pretty_code : Format.formatter -> t -> unit
                            val internal_pretty_code :
                              Type.precedence ->
                              Format.formatter -> t -> unit
                            val pretty : Format.formatter -> t -> unit
                            val varname : t -> string
                            val mem_project :
                              (Project_skeleton.t -> bool) -> t -> bool
                            val copy : t -> t
                          end
                    end
                  module Hashtbl :
                    sig
                      type key = t
                      type 'a t =
                          'a
                          Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.Hashtbl.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val reset : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      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 length : 'a t -> int
                      val stats : 'a t -> Hashtbl.statistics
                      val iter_sorted :
                        ?cmp:(key -> key -> int) ->
                        (key -> '-> unit) -> 'a t -> unit
                      val fold_sorted :
                        ?cmp:(key -> key -> int) ->
                        (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val iter_sorted_by_entry :
                        cmp:(key * '-> key * '-> int) ->
                        (key -> '-> unit) -> 'a t -> unit
                      val fold_sorted_by_entry :
                        cmp:(key * '-> key * '-> int) ->
                        (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val iter_sorted_by_value :
                        cmp:('-> '-> int) ->
                        (key -> '-> unit) -> 'a t -> unit
                      val fold_sorted_by_value :
                        cmp:('-> '-> int) ->
                        (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val structural_descr :
                        Structural_descr.t -> Structural_descr.t
                      val make_type : 'Type.t -> 'a t Type.t
                      val memo : 'a t -> key -> (key -> 'a) -> 'a
                      module Key :
                        sig
                          type t = key
                          val ty : t Type.t
                          val name : string
                          val descr : t Descr.t
                          val packed_descr : Structural_descr.pack
                          val reprs : t list
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          val hash : t -> int
                          val pretty_code : Format.formatter -> t -> unit
                          val internal_pretty_code :
                            Type.precedence -> Format.formatter -> t -> unit
                          val pretty : Format.formatter -> t -> unit
                          val varname : t -> string
                          val mem_project :
                            (Project_skeleton.t -> bool) -> t -> bool
                          val copy : t -> t
                        end
                      module Make :
                        functor (Data : Datatype.S->
                          sig
                            type t = Data.t t
                            val ty : t Type.t
                            val name : string
                            val descr : t Descr.t
                            val packed_descr : Structural_descr.pack
                            val reprs : t list
                            val equal : t -> t -> bool
                            val compare : t -> t -> int
                            val hash : t -> int
                            val pretty_code : Format.formatter -> t -> unit
                            val internal_pretty_code :
                              Type.precedence ->
                              Format.formatter -> t -> unit
                            val pretty : Format.formatter -> t -> unit
                            val varname : t -> string
                            val mem_project :
                              (Project_skeleton.t -> bool) -> t -> bool
                            val copy : t -> t
                          end
                    end
                  val self : State.t
                  val empty : t
                  val hash : t -> int
                  val is_empty : t -> bool
                  val add : key -> V.t -> t -> t
                  val find : key -> t -> V.t
                  val find_key : key -> t -> key
                  val remove : key -> t -> t
                  val mem : key -> t -> bool
                  val iter : (K.t -> V.t -> unit) -> t -> unit
                  val map : (V.t -> V.t) -> t -> t
                  val map' : (K.t -> V.t -> V.t option) -> t -> t
                  val fold : (K.t -> V.t -> '-> 'b) -> t -> '-> 'b
                  val fold_rev : (K.t -> V.t -> '-> 'b) -> t -> '-> 'b
                  val for_all : (K.t -> V.t -> bool) -> t -> bool
                  val exists : (K.t -> V.t -> bool) -> t -> bool
                  val generic_merge :
                    cache:string * bool ->
                    decide:(K.t -> V.t option -> V.t option -> V.t) ->
                    idempotent:bool -> t -> t -> t
                  val symmetric_merge :
                    cache:string * '->
                    decide_none:(K.t -> V.t -> V.t) ->
                    decide_some:(V.t -> V.t -> V.t) -> t -> t -> t
                  val symmetric_inter :
                    cache:string * '->
                    decide_some:(K.t -> V.t -> V.t -> V.t option) ->
                    t -> t -> t
                  val inter_with_shape : 'Hptmap.Shape(K).t -> t -> t
                  type decide_fast =
                    Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.decide_fast =
                      Done
                    | Unknown
                  val generic_predicate :
                    exn ->
                    cache:string * '->
                    decide_fast:(t -> t -> decide_fast) ->
                    decide_fst:(K.t -> V.t -> unit) ->
                    decide_snd:(K.t -> V.t -> unit) ->
                    decide_both:(V.t -> V.t -> unit) -> t -> t -> unit
                  type predicate_type =
                    Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.predicate_type =
                      ExistentialPredicate
                    | UniversalPredicate
                  type predicate_result =
                    Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.predicate_result =
                      PTrue
                    | PFalse
                    | PUnknown
                  type cache_type =
                    Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.cache_type =
                      NoCache
                    | PersistentCache of string
                    | TemporaryCache of string
                  val binary_predicate :
                    cache_type ->
                    predicate_type ->
                    decide_fast:(t -> t -> predicate_result) ->
                    decide_fst:(K.t -> V.t -> bool) ->
                    decide_snd:(K.t -> V.t -> bool) ->
                    decide_both:(K.t -> V.t -> V.t -> bool) -> t -> t -> bool
                  val generic_symmetric_predicate :
                    exn ->
                    decide_fast:(t -> t -> decide_fast) ->
                    decide_one:(K.t -> V.t -> unit) ->
                    decide_both:(V.t -> V.t -> unit) -> t -> t -> unit
                  val symmetric_binary_predicate :
                    cache_type ->
                    predicate_type ->
                    decide_fast:(t -> t -> predicate_result) ->
                    decide_one:(K.t -> V.t -> bool) ->
                    decide_both:(K.t -> V.t -> V.t -> bool) -> t -> t -> bool
                  val decide_fast_inclusion : t -> t -> predicate_result
                  val decide_fast_intersection : t -> t -> predicate_result
                  val cached_fold :
                    cache_name:string ->
                    temporary:bool ->
                    f:(key -> V.t -> 'b) ->
                    joiner:('-> '-> 'b) -> empty:'-> t -> 'b
                  val cached_map :
                    cache:string * int ->
                    temporary:bool -> f:(key -> V.t -> V.t) -> t -> t
                  val singleton : key -> V.t -> t
                  val is_singleton : t -> (key * V.t) option
                  val cardinal : t -> int
                  val min_binding : t -> key * V.t
                  val max_binding : t -> key * V.t
                  val split : key -> t -> t * V.t option * t
                  val compositional_bool : t -> bool
                  val clear_caches : unit -> unit
                  val from_shape :
                    (K.t -> '-> V.t) -> 'Hptmap.Shape(K).t -> t
                  val shape : t -> V.t Hptmap.Shape(K).t
                  val hash_debug : t -> int
                  val pretty_debug : Format.formatter -> t -> unit
                  val comp_prefixes : t -> t -> unit
                  val pretty_prefix :
                    Hptmap.prefix -> Format.formatter -> t -> unit
                  type subtree =
                      Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).M.subtree
                  exception Found_prefix of Hptmap.prefix * subtree * subtree
                  val find_prefix : t -> Hptmap.prefix -> subtree option
                  val hash_subtree : subtree -> int
                  val equal_subtree : subtree -> subtree -> bool
                end
              module Top_Param :
                sig
                  module O :
                    sig
                      type elt = K.t
                      type t = Top_Param.O.t
                      val empty : t
                      val is_empty : t -> bool
                      val mem : elt -> t -> bool
                      val add : elt -> t -> t
                      val singleton : elt -> t
                      val remove : elt -> t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val subset : t -> t -> bool
                      val iter : (elt -> unit) -> t -> unit
                      val fold : (elt -> '-> 'a) -> t -> '-> 'a
                      val for_all : (elt -> bool) -> t -> bool
                      val exists : (elt -> bool) -> t -> bool
                      val filter : (elt -> bool) -> t -> t
                      val partition : (elt -> bool) -> t -> t * t
                      val cardinal : t -> int
                      val elements : t -> elt list
                      val choose : t -> elt
                      val split : elt -> t -> t * bool * t
                      val find : elt -> t -> elt
                      val of_list : elt list -> t
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
                  exception Error_Top
                  type t = Top_Param.t = private Set of O.t | Top
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                  val join : t -> t -> t
                  val is_included : t -> t -> bool
                  val join_and_is_included : t -> t -> t * bool
                  val bottom : t
                  val top : t
                  type widen_hint = O.t
                  val widen : widen_hint -> t -> t -> t
                  val cardinal_zero_or_one : t -> bool
                  val narrow : t -> t -> t
                  val link : t -> t -> t
                  val meet : t -> t -> t
                  val intersects : t -> t -> bool
                  val inject_singleton : O.elt -> t
                  val inject : O.t -> t
                  val empty : t
                  val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
                  val apply1 : (O.elt -> O.elt) -> t -> t
                  val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
                  val iter : (O.elt -> unit) -> t -> unit
                  val exists : (O.elt -> bool) -> t -> bool
                  val for_all : (O.elt -> bool) -> t -> bool
                  val project : t -> O.t
                  val mem : O.elt -> t -> bool
                end
              type map_t = M.t
              type tt =
                Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).tt =
                  Top of Top_Param.t * Origin.t
                | Map of map_t
              val top : tt
              val hash : tt -> int
              val add_or_bottom : M.key -> V.t -> M.t -> M.t
              val bottom : tt
              val inject : M.key -> V.t -> tt
              val top_int : tt
              val inject_top_origin : Origin.t -> Top_Param.O.t -> tt
              val is_in_topset : Top_Param.O.t -> Top_Param.O.elt -> bool
              val pretty : Format.formatter -> tt -> unit
              val find_or_bottom : M.key -> M.t -> V.t
              val split : Top_Param.O.elt -> tt -> V.t * tt
              val inject_map : map_t -> tt
              val get_bases : M.t -> Top_Param.O.t
              exception Error_Top
              val decide_none : '-> '-> 'b
              val decide_some : V.t -> V.t -> V.t
              val equal : tt -> tt -> bool
              val compare : tt -> tt -> int
              val is_bottom : tt -> bool
              val check_join_assert : int ref
              val join : tt -> tt -> tt
              val cached_fold :
                cache_name:string ->
                temporary:bool ->
                f:(M.key -> V.t -> 'a) ->
                projection:(M.key -> V.t) ->
                joiner:('-> '-> 'a) -> empty:'-> tt -> 'a
              val map_offsets : (V.t -> V.t) -> tt -> tt
              val filter_base : (Top_Param.O.elt -> bool) -> tt -> tt
              val meet : tt -> tt -> tt
              val narrow : tt -> tt -> tt
              val equal : tt -> tt -> bool
              val is_included : tt -> tt -> bool
              val join_and_is_included : tt -> tt -> tt * bool
              val link : tt -> tt -> tt
              val intersects : tt -> tt -> bool
              val find_lonely_key : tt -> M.key * V.t
              val diff : tt -> tt -> tt
              val map_i : (K.t -> V.t -> tt) -> tt -> tt
              val fold_bases :
                (Top_Param.O.elt -> '-> 'a) -> tt -> '-> 'a
              val fold_i : (K.t -> V.t -> '-> 'a) -> tt -> '-> 'a
              val fold_topset_ok :
                (Top_Param.O.elt -> V.t -> '-> 'a) -> tt -> '-> 'a
              type t = tt
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
              module Set :
                sig
                  type elt = t
                  type t =
                      Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).Set.t
                  val empty : t
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val remove : elt -> t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val subset : t -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val filter : (elt -> bool) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val cardinal : t -> int
                  val elements : t -> elt list
                  val choose : t -> elt
                  val split : elt -> t -> t * bool * t
                  val find : elt -> t -> elt
                  val of_list : elt list -> t
                  val min_elt : t -> elt
                  val max_elt : t -> elt
                  val nearest_elt_le : elt -> t -> elt
                  val nearest_elt_ge : elt -> t -> elt
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                end
              module Map :
                sig
                  type key = t
                  type 'a t =
                      'a
                      Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).Map.t
                  val empty : 'a t
                  val is_empty : 'a t -> bool
                  val mem : key -> 'a t -> bool
                  val add : key -> '-> 'a t -> 'a t
                  val singleton : key -> '-> 'a t
                  val remove : key -> 'a t -> 'a t
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val for_all : (key -> '-> bool) -> 'a t -> bool
                  val exists : (key -> '-> bool) -> 'a t -> bool
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val cardinal : 'a t -> int
                  val bindings : 'a t -> (key * 'a) list
                  val min_binding : 'a t -> key * 'a
                  val max_binding : 'a t -> key * 'a
                  val choose : 'a t -> key * 'a
                  val split : key -> 'a t -> 'a t * 'a option * 'a t
                  val find : key -> 'a t -> 'a
                  val map : ('-> 'b) -> 'a t -> 'b t
                  val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                  module Key :
                    sig
                      type t = key
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
                  module Make :
                    functor (Data : Datatype.S->
                      sig
                        type t = Data.t t
                        val ty : t Type.t
                        val name : string
                        val descr : t Descr.t
                        val packed_descr : Structural_descr.pack
                        val reprs : t list
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val hash : t -> int
                        val pretty_code : Format.formatter -> t -> unit
                        val internal_pretty_code :
                          Type.precedence -> Format.formatter -> t -> unit
                        val pretty : Format.formatter -> t -> unit
                        val varname : t -> string
                        val mem_project :
                          (Project_skeleton.t -> bool) -> t -> bool
                        val copy : t -> t
                      end
                end
              module Hashtbl :
                sig
                  type key = t
                  type 'a t =
                      'a
                      Make_without_cardinal(K)(Top_Param)(V)(Comp)(L)(Null_Behavior).Hashtbl.t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val reset : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key -> '-> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  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 length : 'a t -> int
                  val stats : 'a t -> Hashtbl.statistics
                  val iter_sorted :
                    ?cmp:(key -> key -> int) ->
                    (key -> '-> unit) -> 'a t -> unit
                  val fold_sorted :
                    ?cmp:(key -> key -> int) ->
                    (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val iter_sorted_by_entry :
                    cmp:(key * '-> key * '-> int) ->
                    (key -> '-> unit) -> 'a t -> unit
                  val fold_sorted_by_entry :
                    cmp:(key * '-> key * '-> int) ->
                    (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val iter_sorted_by_value :
                    cmp:('-> '-> int) ->
                    (key -> '-> unit) -> 'a t -> unit
                  val fold_sorted_by_value :
                    cmp:('-> '-> int) ->
                    (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val structural_descr :
                    Structural_descr.t -> Structural_descr.t
                  val make_type : 'Type.t -> 'a t Type.t
                  val memo : 'a t -> key -> (key -> 'a) -> 'a
                  module Key :
                    sig
                      type t = key
                      val ty : t Type.t
                      val name : string
                      val descr : t Descr.t
                      val packed_descr : Structural_descr.pack
                      val reprs : t list
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val hash : t -> int
                      val pretty_code : Format.formatter -> t -> unit
                      val internal_pretty_code :
                        Type.precedence -> Format.formatter -> t -> unit
                      val pretty : Format.formatter -> t -> unit
                      val varname : t -> string
                      val mem_project :
                        (Project_skeleton.t -> bool) -> t -> bool
                      val copy : t -> t
                    end
                  module Make :
                    functor (Data : Datatype.S->
                      sig
                        type t = Data.t t
                        val ty : t Type.t
                        val name : string
                        val descr : t Descr.t
                        val packed_descr : Structural_descr.pack
                        val reprs : t list
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val hash : t -> int
                        val pretty_code : Format.formatter -> t -> unit
                        val internal_pretty_code :
                          Type.precedence -> Format.formatter -> t -> unit
                        val pretty : Format.formatter -> t -> unit
                        val varname : t -> string
                        val mem_project :
                          (Project_skeleton.t -> bool) -> t -> bool
                        val copy : t -> t
                      end
                end
              val clear_caches : unit -> unit
              type widen_hint = K.t -> V.widen_hint
              val widen : (K.t -> V.widen_hint) -> tt -> tt -> tt
              val find_lonely_binding : tt -> M.key * V.t
              val cardinal_zero_or_one : t -> bool
              val cardinal_less_than : tt -> int -> int
              val fold_enum : (tt -> '-> 'a) -> tt -> '-> 'a
              val diff_if_one : tt -> tt -> tt
            end