functor (K : Abstract_interp.Key->
  functor
    (Top_Param : sig
                   module O :
                     sig
                       type elt = K.t
                       type 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
                       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 elements : t -> elt list
                       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 cardinal : t -> int
                       val min_elt : t -> elt
                       val contains_single_elt : t -> elt option
                     end
                   type tt = private Set of O.t | Top
                   exception Error_Top
                   exception Error_Bottom
                   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
                   type widen_hint = O.t
                   val join : t -> t -> t
                   val link : t -> t -> t
                   val meet : t -> t -> t
                   val narrow : t -> t -> t
                   val bottom : t
                   val top : t
                   val is_included : t -> t -> bool
                   val is_included_exn : t -> t -> unit
                   val intersects : t -> t -> bool
                   val widen : widen_hint -> t -> t -> t
                   val cardinal_zero_or_one : t -> bool
                   val cardinal_less_than : t -> int -> int
                   val tag : t -> int
                   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 project : t -> O.t
                   val mem : O.elt -> t -> bool
                 end->
    functor (V : Lattice_with_rehash->
      functor (L : sig val v : (K.t * V.t) list list end->
        functor (Null_Behavior : sig val zone : bool end->
          sig
            module M :
              sig
                type key = K.t
                type leaf_annot = bool
                type branch_annot = Hptmap.Tag_comp.t
                type tt = private
                    Empty
                  | Leaf of key * V.t * bool
                  | Branch of int * int * tt * tt * Hptmap.Tag_comp.t
                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
                val empty : t
                val tag : t -> int
                val hash_debug : t -> int
                val is_empty : t -> bool
                val comp : t -> bool
                val add : key -> V.t -> t -> t
                val find : key -> t -> V.t
                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 fold : (K.t -> V.t -> '-> 'a) -> t -> '-> 'a
                val comp_prefixes : t -> t -> unit
                val pretty_prefix :
                  Hptmap.prefix -> Format.formatter -> t -> unit
                type 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
                val generic_merge :
                  cache:string * int ->
                  decide:(K.t -> V.t option -> V.t option -> V.t) ->
                  t -> t -> t
                val symetric_merge :
                  cache:string * int ->
                  decide_none:(K.t -> V.t -> V.t) ->
                  decide_some:(V.t -> V.t -> V.t) -> t -> t -> t
                val generic_is_included :
                  exn ->
                  cache:string * int ->
                  decide_fst:(K.t -> V.t -> unit) ->
                  decide_snd:(K.t -> V.t -> unit) ->
                  decide_both:(V.t -> V.t -> unit) -> t -> t -> unit
                val cached_fold :
                  cache:string * int ->
                  temporary:bool ->
                  f:(key -> V.t -> 'a) ->
                  joiner:('-> '-> 'a) -> empty:'-> t -> 'a
                val cached_map :
                  cache:string * int ->
                  temporary:bool -> f:(key -> V.t -> V.t) -> t -> t
                val is_singleton : t -> (key * V.t) option
                val min_binding : t -> key * V.t
              end
            module Top_Param :
              sig
                module O :
                  sig
                    type elt = K.t
                    type t = Top_Param.O.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
                    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 elements : t -> elt list
                    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 cardinal : t -> int
                    val min_elt : t -> elt
                    val contains_single_elt : t -> elt option
                  end
                type tt = Top_Param.tt = private Set of O.t | Top
                exception Error_Top
                exception Error_Bottom
                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
                type widen_hint = O.t
                val join : t -> t -> t
                val link : t -> t -> t
                val meet : t -> t -> t
                val narrow : t -> t -> t
                val bottom : t
                val top : t
                val is_included : t -> t -> bool
                val is_included_exn : t -> t -> unit
                val intersects : t -> t -> bool
                val widen : widen_hint -> t -> t -> t
                val cardinal_zero_or_one : t -> bool
                val cardinal_less_than : t -> int -> int
                val tag : t -> int
                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 project : t -> O.t
                val mem : O.elt -> t -> bool
              end
            type map_t = Map_Lattice.Make.M.t
            type tt =
                Top of Map_Lattice.Make.Top_Param.t * Origin.t
              | Map of Map_Lattice.Make.map_t
            type widen_hint =
                Map_Lattice.Make.Top_Param.widen_hint * (K.t -> V.widen_hint)
            val top : Map_Lattice.Make.tt
            val hash : Map_Lattice.Make.tt -> int
            val tag : Map_Lattice.Make.tt -> int
            val add_or_bottom :
              Map_Lattice.Make.M.key ->
              V.t -> Map_Lattice.Make.M.t -> Map_Lattice.Make.M.t
            val bottom : Map_Lattice.Make.tt
            val inject : Map_Lattice.Make.M.key -> V.t -> Map_Lattice.Make.tt
            val top_int : Map_Lattice.Make.tt
            val inject_top_origin :
              Origin.t ->
              Map_Lattice.Make.Top_Param.O.t -> Map_Lattice.Make.tt
            val is_in_set :
              set:Map_Lattice.Make.Top_Param.O.t ->
              Map_Lattice.Make.Top_Param.O.elt -> bool
            val pretty : Format.formatter -> Map_Lattice.Make.tt -> unit
            val find_or_bottom :
              Map_Lattice.Make.M.key -> Map_Lattice.Make.M.t -> V.t
            val split :
              Map_Lattice.Make.Top_Param.O.elt ->
              Map_Lattice.Make.tt -> V.t * Map_Lattice.Make.tt
            val inject_map : Map_Lattice.Make.map_t -> Map_Lattice.Make.tt
            val get_bases :
              Map_Lattice.Make.M.t -> Map_Lattice.Make.Top_Param.O.t
            exception Error_Bottom
            exception Error_Top
            val decide_none : '-> '-> 'b
            val decide_some : V.t -> V.t -> V.t
            val equal : tt -> tt -> bool
            val compare : Map_Lattice.Make.tt -> Map_Lattice.Make.tt -> int
            val is_bottom : Map_Lattice.Make.tt -> bool
            val check_join_assert : int Pervasives.ref
            val join :
              Map_Lattice.Make.tt ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val cached_fold :
              cache:string * int ->
              temporary:bool ->
              f:(Map_Lattice.Make.M.key -> V.t -> 'a) ->
              projection:(Map_Lattice.Make.M.key -> V.t) ->
              joiner:('-> '-> 'a) ->
              empty:'-> Map_Lattice.Make.tt -> 'a
            val map_offsets :
              (V.t -> V.t) -> Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            exception Not_exclusive
            val find_exclusive :
              Map_Lattice.Make.M.key -> Map_Lattice.Make.tt -> V.t
            exception Not_all_keys
            val get_keys_exclusive : V.t -> Map_Lattice.Make.tt -> K.t list
            val filter_base :
              (Map_Lattice.Make.Top_Param.O.elt -> bool) ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val meet :
              Map_Lattice.Make.tt ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val narrow :
              Map_Lattice.Make.tt ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val widen :
              'a * (K.t -> V.widen_hint) ->
              Map_Lattice.Make.tt ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val equal : Map_Lattice.Make.tt -> Map_Lattice.Make.tt -> bool
            val decide_fst : '-> '-> 'c
            val decide_snd : '-> '-> unit
            val decide_both : V.t -> V.t -> unit
            val is_included_exn :
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt -> unit
            val check_is_included_assert : int Pervasives.ref
            val is_included :
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt -> bool
            val link :
              Map_Lattice.Make.tt ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            exception Found_inter
            val intersects :
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt -> bool
            val find_lonely_key : Map_Lattice.Make.tt -> K.t * V.t
            val find_lonely_binding : Map_Lattice.Make.tt -> K.t * V.t
            val cardinal_zero_or_one : Map_Lattice.Make.tt -> bool
            val cardinal_less_than : Map_Lattice.Make.tt -> int -> int
            val splitting_cardinal_less_than :
              split_non_enumerable:int -> Map_Lattice.Make.tt -> int -> int
            val diff_if_one :
              Map_Lattice.Make.tt ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val diff :
              Map_Lattice.Make.tt ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val map_i :
              (K.t -> V.t -> Map_Lattice.Make.tt) ->
              Map_Lattice.Make.tt -> Map_Lattice.Make.tt
            val fold_bases :
              (Map_Lattice.Make.Top_Param.O.elt -> '-> 'a) ->
              Map_Lattice.Make.tt -> '-> 'a
            val fold_i :
              (K.t -> V.t -> '-> 'a) -> Map_Lattice.Make.tt -> '-> 'a
            val fold_topset_ok :
              (Map_Lattice.Make.Top_Param.O.elt -> V.t -> '-> 'a) ->
              Map_Lattice.Make.tt -> '-> 'a
            val fold_enum :
              split_non_enumerable:int ->
              (Map_Lattice.Make.tt -> '-> 'a) ->
              Map_Lattice.Make.tt -> '-> 'a
            val fold_enum_by_base :
              (Map_Lattice.Make.tt -> '-> 'a) ->
              Map_Lattice.Make.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
                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 compare : t -> t -> int
                val equal : t -> t -> bool
                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 min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val split : elt -> t -> t * bool * 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 hash : t -> int
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty_code : 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
                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
                val create : int -> 'a t
                val clear : '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
                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
          end