sig
  module Make :
    functor
      (C : Sigs.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 diff : t -> t -> t
                                  val subset : t -> t -> bool
                                  val intersect : t -> t -> bool
                                  val of_list : elt list -> t
                                  type 'a mapping = 'a map
                                  val mapping :
                                    (elt -> 'a) -> t -> 'a mapping
                                end
                            end->
      sig
        type chunk = C.t
        module Chunk :
          sig
            type t = C.t
            type set = H.set
            type 'a map = 'H.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 diff : t -> t -> t
                val subset : t -> t -> bool
                val intersect : t -> t -> bool
                val of_list : elt list -> t
                type 'a mapping = 'a map
                val mapping : (elt -> 'a) -> t -> 'a mapping
              end
          end
        type domain = Chunk.Set.t
        type t
        val pretty : Format.formatter -> t -> unit
        val create : unit -> t
        val mem : t -> chunk -> bool
        val get : t -> chunk -> Lang.F.var
        val value : t -> chunk -> Lang.F.term
        val copy : t -> t
        val join : t -> t -> Passive.t
        val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
        val choose : t -> t -> t
        val merge : t -> t -> t * Passive.t * Passive.t
        val merge_list : t list -> t * Passive.t list
        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_chunk : t -> chunk -> t
        val havoc : t -> domain -> t
        val havoc_any : call:bool -> t -> t
        val remove_chunks : t -> domain -> t
        val domain : t -> domain
        val union : domain -> domain -> domain
        val empty : domain
        val writes : t Sigs.sequence -> domain
      end
end