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