sig   module Make :     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 end