functor   (C : Memory.Chunk) (H : sig                             type t = C.t                             type set                             type 'a map                             val hash : t -> int                             val equal : t -> t -> bool                             val compare : t -> t -> int                             module Map :                               sig                                 type key = t                                 type 'a t = 'a map                                 val empty : 'a t                                 val add : key -> '-> 'a t -> 'a t                                 val mem : key -> 'a t -> bool                                 val find : key -> 'a t -> 'a                                 val findk : key -> 'a t -> key * 'a                                 val size : 'a t -> int                                 val is_empty : 'a t -> bool                                 val insert :                                   (key -> '-> '-> 'a) ->                                   key -> '-> 'a t -> 'a t                                 val change :                                   (key -> '-> 'a option -> 'a option) ->                                   key -> '-> 'a t -> 'a t                                 val map : ('-> 'b) -> 'a t -> 'b t                                 val mapi : (key -> '-> 'b) -> 'a t -> 'b t                                 val mapf :                                   (key -> '-> 'b option) -> 'a t -> 'b t                                 val mapq :                                   (key -> '-> 'a option) -> 'a t -> 'a t                                 val filter :                                   (key -> '-> bool) -> 'a t -> 'a t                                 val partition :                                   (key -> '-> bool) -> 'a t -> 'a t * 'a t                                 val iter :                                   (key -> '-> unit) -> 'a t -> unit                                 val fold :                                   (key -> '-> '-> 'b) -> 'a t -> '-> 'b                                 val iter_sorted :                                   (key -> '-> unit) -> 'a t -> unit                                 val fold_sorted :                                   (key -> '-> '-> 'b) -> 'a t -> '-> 'b                                 val union :                                   (key -> '-> '-> 'a) ->                                   'a t -> 'a t -> 'a t                                 val inter :                                   (key -> '-> '-> 'c) ->                                   'a t -> 'b t -> 'c t                                 val interf :                                   (key -> '-> '-> 'c option) ->                                   'a t -> 'b t -> 'c t                                 val interq :                                   (key -> '-> '-> 'a option) ->                                   'a t -> 'a t -> 'a t                                 val diffq :                                   (key -> '-> '-> 'a option) ->                                   'a t -> 'a t -> 'a t                                 val subset :                                   (key -> '-> '-> bool) ->                                   'a t -> 'b t -> bool                                 val equal :                                   ('-> '-> bool) -> 'a t -> 'a t -> bool                                 val iterk :                                   (key -> '-> '-> unit) ->                                   'a t -> 'b t -> unit                                 val iter2 :                                   (key -> 'a option -> 'b option -> unit) ->                                   'a t -> 'b t -> unit                                 val merge :                                   (key -> 'a option -> 'b option -> 'c option) ->                                   'a t -> 'b t -> 'c t                                 type domain = set                                 val domain : 'a t -> domain                               end                             module Set :                               sig                                 type elt = t                                 type t = set                                 val empty : t                                 val add : elt -> t -> t                                 val singleton : elt -> t                                 val elements : t -> elt list                                 val is_empty : t -> bool                                 val mem : elt -> t -> bool                                 val iter : (elt -> unit) -> t -> unit                                 val fold : (elt -> '-> 'a) -> t -> '-> 'a                                 val filter : (elt -> bool) -> t -> t                                 val partition : (elt -> bool) -> t -> t * t                                 val for_all : (elt -> bool) -> t -> bool                                 val exists : (elt -> bool) -> t -> bool                                 val iter_sorted : (elt -> unit) -> t -> unit                                 val fold_sorted :                                   (elt -> '-> 'a) -> t -> '-> 'a                                 val union : t -> t -> t                                 val inter : t -> t -> t                                 val subset : t -> t -> bool                                 val intersect : t -> t -> bool                                 type 'a mapping = 'a map                                 val mapping : (elt -> 'a) -> t -> 'a mapping                               end                           end->   sig     type chunk = C.t     type domain = H.set     type t     val create : unit -> t     val copy : t -> t     val merge : t -> t -> t * Passive.t * Passive.t     val join : t -> t -> Passive.t     val assigned : t -> t -> domain -> Lang.F.pred Bag.t     val mem : t -> chunk -> bool     val get : t -> chunk -> Lang.F.var     val value : t -> chunk -> Lang.F.term     val iter : (chunk -> Lang.F.var -> unit) -> t -> unit     val iter2 :       (chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->       t -> t -> unit     val havoc : t -> domain -> t     val havoc_chunk : t -> chunk -> t     val havoc_any : call:bool -> t -> t     val domain : t -> domain     val union : domain -> domain -> domain     val empty : domain     val pretty : Format.formatter -> t -> unit   end