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