functor
  (WpModel : sig
               module D : Mdata.S
               module A :
                 sig
                   module D :
                     sig
                       module F :
                         sig
                           type 'a term = 'D.F.term
                           type pred = D.F.pred
                           val e_int : int -> Formula.integer term
                           val e_call :
                             string ->
                             Formula.abstract term list ->
                             Formula.abstract term
                           val p_call :
                             string -> Formula.abstract term list -> pred
                           val wrap : 'a term -> Formula.abstract term
                           val unwrap : Formula.abstract term -> 'a term
                           val e_true : Formula.boolean term
                           val e_false : Formula.boolean term
                           val e_int : int -> Formula.integer term
                           val e_float : float -> Formula.real term
                           val e_icst : string -> Formula.integer term
                           val e_rcst : string -> Formula.real term
                           val e_int64 : int64 -> Formula.integer term
                           val e_ineg :
                             Formula.integer term -> Formula.integer term
                           val e_rneg :
                             Formula.real term -> Formula.real term
                           val e_iop :
                             Formula.integer_op ->
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_rop :
                             Formula.real_op ->
                             Formula.real term ->
                             Formula.real term -> Formula.real term
                           val e_icmp :
                             Formula.cmp_op ->
                             Formula.integer term ->
                             Formula.integer term -> Formula.boolean term
                           val e_rcmp :
                             Formula.cmp_op ->
                             Formula.real term ->
                             Formula.real term -> Formula.boolean term
                           val p_icmp :
                             Formula.cmp_op ->
                             Formula.integer term ->
                             Formula.integer term -> pred
                           val p_rcmp :
                             Formula.cmp_op ->
                             Formula.real term -> Formula.real term -> pred
                           val e_bnot :
                             Formula.integer term -> Formula.integer term
                           val e_band :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_bor :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_bxor :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_lshift :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_rshift :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val integer_of_real :
                             Formula.real term -> Formula.integer term
                           val real_of_integer :
                             Formula.integer term -> Formula.real term
                           val e_bool :
                             Formula.boolean term -> Formula.integer term
                           val e_not :
                             Formula.boolean term -> Formula.boolean term
                           val e_and :
                             Formula.boolean term ->
                             Formula.boolean term -> Formula.boolean term
                           val e_or :
                             Formula.boolean term ->
                             Formula.boolean term -> Formula.boolean term
                           val e_cond :
                             Formula.boolean term ->
                             'a term -> 'a term -> 'a term
                           val p_cond :
                             Formula.boolean term -> pred -> pred -> pred
                           val p_true : pred
                           val p_false : pred
                           val p_bool : Formula.boolean term -> pred
                           val p_and : pred -> pred -> pred
                           val p_or : pred -> pred -> pred
                           val p_xor : pred -> pred -> pred
                           val p_not : pred -> pred
                           val p_implies : pred -> pred -> pred
                           val p_iff : pred -> pred -> pred
                           val p_eq : 'a term -> 'a term -> pred
                           val p_neq : 'a term -> 'a term -> pred
                           val p_conj : pred list -> pred
                           val p_disj : pred list -> pred
                           val p_named : string -> pred -> pred
                           val is_true : pred -> bool
                           val is_false : pred -> bool
                           val huge_term : int -> 'a term -> bool
                           val huge_pred : int -> pred -> bool
                           type var = D.F.var
                           type pool = D.F.pool
                           val pool : unit -> pool
                           val fresh : pool -> string -> Formula.kind -> var
                           val freshen : pool -> var -> var
                           val var : var -> 'a term
                           val eq_var : var -> var -> bool
                           val name_of_var : var -> string
                           val tau_of_var : var -> Formula.tau
                           val kind_of_var : var -> Formula.kind
                           val term_has_var : var list -> 'a term -> bool
                           val pred_has_var : var list -> pred -> bool
                           val term_closed : 'a term -> bool
                           val pred_closed : pred -> bool
                           val p_forall : var list -> pred -> pred
                           val p_exists : var list -> pred -> pred
                           val p_subst :
                             (var -> var option) ->
                             var -> 'a term -> pred -> pred
                           val e_subst :
                             (var -> var option) ->
                             var -> 'a term -> 'b term -> 'b term
                           val e_rename :
                             (var * var) list -> 'a term -> 'a term
                           val equal_terms : 'a term -> 'a term -> bool
                           type alpha = D.F.alpha
                           val empty_alpha : alpha
                           val fold_alpha :
                             (var -> var -> '-> 'a) -> alpha -> '-> 'a
                           val p_more_alpha_cv :
                             alpha -> pred -> alpha * pred
                           val p_alpha_cv : pred -> var list * pred
                           val pp_var : Format.formatter -> var -> unit
                           val pp_term : Format.formatter -> 'a term -> unit
                           val pp_pred : Format.formatter -> pred -> unit
                           val pp_decl :
                             Format.formatter ->
                             pred Formula.declaration -> unit
                           val pp_goal :
                             Format.formatter -> string -> pred -> unit
                         end
                       type format = Formula.m_format F.term
                       type abstract = Formula.abstract F.term
                       type integer = Formula.integer F.term
                       type real = Formula.real F.term
                       type boolean = Formula.boolean F.term
                       type record = Formula.m_array F.term
                       type urecord = Formula.m_array F.term
                       type array = Formula.m_array F.term
                       type set = Formula.m_set F.term
                       type name = Formula.integer F.term
                       type pointer = Formula.m_pointer F.term
                       val pp_kind : Format.formatter -> Mdata.kind -> unit
                       type interval =
                         D.interval = {
                         inf : integer option;
                         sup : integer option;
                       }
                       type 'a assigned =
                         'D.assigned =
                           Aloc of Ctypes.c_object * 'a
                         | Arange of Ctypes.c_object * 'a * interval
                       val pp_interval : Format.formatter -> interval -> unit
                       val e_app0 : string -> 'F.term
                       val e_app1 : string -> 'F.term -> 'F.term
                       val e_app2 :
                         string -> 'F.term -> 'F.term -> 'F.term
                       val e_app3 :
                         string ->
                         'F.term -> 'F.term -> 'F.term -> 'F.term
                       val e_app4 :
                         string ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> 'F.term
                       val e_app5 :
                         string ->
                         'F.term ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> 'F.term
                       val p_app0 : string -> F.pred
                       val p_app1 : string -> 'F.term -> F.pred
                       val p_app2 :
                         string -> 'F.term -> 'F.term -> F.pred
                       val p_app3 :
                         string ->
                         'F.term -> 'F.term -> 'F.term -> F.pred
                       val p_app4 :
                         string ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> F.pred
                       val p_app5 :
                         string ->
                         'F.term ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> F.pred
                       val tau_of_logic_type :
                         Cil_types.logic_type -> Formula.tau
                       type context = D.context
                       type bindings = D.bindings
                       class type hint =
                         object
                           method capture : F.var list -> unit
                           method has_var : F.var list -> bool
                           method pretty : Format.formatter -> unit
                           method subst :
                             F.var -> Formula.abstract F.term -> unit
                         end
                       val closed : bindings
                       val close : bindings -> F.pred -> F.pred
                       val capture : hint list -> bindings -> unit
                       val push :
                         string -> F.pool -> bindings -> hint list -> context
                       val pop : string -> context -> bindings
                       val kill : string -> context -> unit
                       val flush : string -> context -> F.pred -> F.pred
                       val term_such_that :
                         Formula.tau -> ('F.term -> F.pred) -> 'F.term
                       val forall : F.var list -> F.pred -> F.pred
                       val exists : F.var list -> F.pred -> F.pred
                       val subst : F.var -> 'F.term -> F.pred -> F.pred
                       val fresh : string -> Mdata.vkind -> F.var
                       val alpha : F.var -> F.var option
                       val pool : unit -> F.pool
                       val vkind_of_var : F.var -> Mdata.vkind
                       val has_vars : F.var list -> F.pred -> bool
                       type substitution = D.substitution
                       val apply : substitution -> 'F.term -> 'F.term
                       type havoc =
                         D.havoc =
                           Fresh of F.var
                         | Update of F.var *
                             (substitution -> Formula.abstract F.term)
                       val havoc_static : havoc list -> F.pred -> F.pred
                       val havoc_inductive : havoc list -> F.pred -> F.pred
                       val clear : unit -> unit
                       val on_clear : (unit -> unit) -> unit
                       val fresh_name : string -> string -> string
                       val add_declaration :
                         F.pred Formula.declaration -> unit
                       val iter :
                         Formula.section ->
                         (F.pred Formula.declaration -> unit) -> unit
                       val iter_all :
                         (F.pred Formula.declaration -> unit) -> unit
                       val dummy : unit -> F.pred
                       module type Identifiable =
                         sig
                           type t
                           module H : Hashtbl.S
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module type Registry =
                         sig
                           type t
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                         end
                       module type Declarator =
                         sig
                           type t
                           module H : Hashtbl.S
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                           val clear : unit -> unit
                           val section : Formula.section
                           val declare : t -> string -> F.pred Formula.item
                         end
                       module Register :
                         functor (D : Declarator->
                           sig
                             type t = D.t
                             val define : t -> unit
                             val get_definition :
                               t -> F.pred Formula.declaration
                             val on_definition :
                               (t -> F.pred Formula.declaration -> unit) ->
                               unit
                           end
                       module Varinfo :
                         sig
                           type t = Cil_types.varinfo
                           module H :
                             sig
                               type key = D.Varinfo.H.key
                               type 'a t = 'D.Varinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Varaddr :
                         sig
                           type t = Cil_types.varinfo
                           module H :
                             sig
                               type key = D.Varaddr.H.key
                               type 'a t = 'D.Varaddr.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Fieldinfo :
                         sig
                           type t = Cil_types.fieldinfo
                           module H :
                             sig
                               type key = D.Fieldinfo.H.key
                               type 'a t = 'D.Fieldinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Compinfo :
                         sig
                           type t = Cil_types.compinfo
                           module H :
                             sig
                               type key = D.Compinfo.H.key
                               type 'a t = 'D.Compinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Arrayinfo :
                         sig
                           type t = Ctypes.arrayinfo
                           module H :
                             sig
                               type key = D.Arrayinfo.H.key
                               type 'a t = 'D.Arrayinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Logicvar :
                         sig
                           type t = Cil_types.logic_var
                           module H :
                             sig
                               type key = D.Logicvar.H.key
                               type 'a t = 'D.Logicvar.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module type Indexed =
                         sig
                           type t
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Dindex :
                         functor (I : Identifiable->
                           sig
                             type t = I.t
                             val define : t -> unit
                             val get_definition :
                               t -> F.pred Formula.declaration
                             val on_definition :
                               (t -> F.pred Formula.declaration -> unit) ->
                               unit
                             val get_ind : t -> integer
                           end
                       module Findex :
                         sig
                           type t = Cil_types.fieldinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Xindex :
                         sig
                           type t = Cil_types.varinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Aindex :
                         sig
                           type t = Cil_types.varinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Tindex :
                         sig
                           type t = Cil_types.compinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       val modulo : Ctypes.c_int -> integer -> integer
                       val guard : Ctypes.c_int -> integer -> F.pred
                       val i_convert :
                         Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                       val round : Ctypes.c_float -> real -> real
                       val f_guard : Ctypes.c_float -> real -> F.pred
                       val f_convert :
                         Ctypes.c_float -> Ctypes.c_float -> real -> real
                       val has_type :
                         abstract -> Cil_types.logic_type -> F.pred
                       val get_range_index : array -> interval -> abstract
                       val set_range_index : array -> interval -> array
                       val empty : set
                       val singleton : abstract -> set
                       val union : set -> set -> set
                       val unions : set list -> set
                       val inter : set -> set -> set
                       val remove : set -> set -> set
                       val set_of_list : abstract list -> set
                       val add_set : set -> set -> set
                       val mult_set : set -> set -> set
                       val neg_set : set -> set
                       val interval : interval -> set
                       val equal_pointer_bool : pointer -> pointer -> boolean
                       val lt_pointer_bool : pointer -> pointer -> boolean
                       val le_pointer_bool : pointer -> pointer -> boolean
                       val lt_pointer : pointer -> pointer -> F.pred
                       val le_pointer : pointer -> pointer -> F.pred
                       val minus_pointer : pointer -> pointer -> integer
                       val is_null : pointer -> boolean
                       val null : pointer
                       val tau_of_object : Ctypes.c_object -> Formula.tau
                       val tau_of_ctype : Cil_types.typ -> Formula.tau
                       val int_format : format
                       val real_format : format
                       val pointer_format : format
                       val record_format : format
                       val urecord_format : format
                       val array_format : format -> format
                       val format_of_object : Ctypes.c_object -> format
                       val decode : format -> abstract -> 'F.term
                       val encode : format -> 'F.term -> abstract
                       val acc_field :
                         record -> Cil_types.fieldinfo -> abstract
                       val upd_field :
                         record -> Cil_types.fieldinfo -> abstract -> record
                       val acc_index : array -> integer -> abstract
                       val upd_index : array -> integer -> abstract -> array
                       val equal :
                         Ctypes.c_object -> abstract -> abstract -> F.pred
                       val eq_array :
                         Ctypes.arrayinfo -> array -> array -> F.pred
                       val eq_record :
                         Cil_types.compinfo -> record -> record -> F.pred
                     end
                   val i_neg : Ctypes.c_int -> D.integer -> D.integer
                   val i_op :
                     Ctypes.c_int ->
                     Formula.integer_op ->
                     D.integer -> D.integer -> D.integer
                   val i_cmp :
                     Ctypes.c_int ->
                     Formula.cmp_op -> D.integer -> D.integer -> D.boolean
                   val bits_not : Ctypes.c_int -> D.integer -> D.integer
                   val bits_and :
                     Ctypes.c_int -> D.integer -> D.integer -> D.integer
                   val bits_or :
                     Ctypes.c_int -> D.integer -> D.integer -> D.integer
                   val bits_xor :
                     Ctypes.c_int -> D.integer -> D.integer -> D.integer
                   val bits_lshift :
                     Ctypes.c_int -> D.integer -> D.integer -> D.integer
                   val bits_rshift :
                     Ctypes.c_int -> D.integer -> D.integer -> D.integer
                 end
               module R :
                 sig
                   module D :
                     sig
                       module F :
                         sig
                           type 'a term = 'D.F.term
                           type pred = D.F.pred
                           val e_int : int -> Formula.integer term
                           val e_call :
                             string ->
                             Formula.abstract term list ->
                             Formula.abstract term
                           val p_call :
                             string -> Formula.abstract term list -> pred
                           val wrap : 'a term -> Formula.abstract term
                           val unwrap : Formula.abstract term -> 'a term
                           val e_true : Formula.boolean term
                           val e_false : Formula.boolean term
                           val e_int : int -> Formula.integer term
                           val e_float : float -> Formula.real term
                           val e_icst : string -> Formula.integer term
                           val e_rcst : string -> Formula.real term
                           val e_int64 : int64 -> Formula.integer term
                           val e_ineg :
                             Formula.integer term -> Formula.integer term
                           val e_rneg :
                             Formula.real term -> Formula.real term
                           val e_iop :
                             Formula.integer_op ->
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_rop :
                             Formula.real_op ->
                             Formula.real term ->
                             Formula.real term -> Formula.real term
                           val e_icmp :
                             Formula.cmp_op ->
                             Formula.integer term ->
                             Formula.integer term -> Formula.boolean term
                           val e_rcmp :
                             Formula.cmp_op ->
                             Formula.real term ->
                             Formula.real term -> Formula.boolean term
                           val p_icmp :
                             Formula.cmp_op ->
                             Formula.integer term ->
                             Formula.integer term -> pred
                           val p_rcmp :
                             Formula.cmp_op ->
                             Formula.real term -> Formula.real term -> pred
                           val e_bnot :
                             Formula.integer term -> Formula.integer term
                           val e_band :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_bor :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_bxor :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_lshift :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val e_rshift :
                             Formula.integer term ->
                             Formula.integer term -> Formula.integer term
                           val integer_of_real :
                             Formula.real term -> Formula.integer term
                           val real_of_integer :
                             Formula.integer term -> Formula.real term
                           val e_bool :
                             Formula.boolean term -> Formula.integer term
                           val e_not :
                             Formula.boolean term -> Formula.boolean term
                           val e_and :
                             Formula.boolean term ->
                             Formula.boolean term -> Formula.boolean term
                           val e_or :
                             Formula.boolean term ->
                             Formula.boolean term -> Formula.boolean term
                           val e_cond :
                             Formula.boolean term ->
                             'a term -> 'a term -> 'a term
                           val p_cond :
                             Formula.boolean term -> pred -> pred -> pred
                           val p_true : pred
                           val p_false : pred
                           val p_bool : Formula.boolean term -> pred
                           val p_and : pred -> pred -> pred
                           val p_or : pred -> pred -> pred
                           val p_xor : pred -> pred -> pred
                           val p_not : pred -> pred
                           val p_implies : pred -> pred -> pred
                           val p_iff : pred -> pred -> pred
                           val p_eq : 'a term -> 'a term -> pred
                           val p_neq : 'a term -> 'a term -> pred
                           val p_conj : pred list -> pred
                           val p_disj : pred list -> pred
                           val p_named : string -> pred -> pred
                           val is_true : pred -> bool
                           val is_false : pred -> bool
                           val huge_term : int -> 'a term -> bool
                           val huge_pred : int -> pred -> bool
                           type var = D.F.var
                           type pool = D.F.pool
                           val pool : unit -> pool
                           val fresh : pool -> string -> Formula.kind -> var
                           val freshen : pool -> var -> var
                           val var : var -> 'a term
                           val eq_var : var -> var -> bool
                           val name_of_var : var -> string
                           val tau_of_var : var -> Formula.tau
                           val kind_of_var : var -> Formula.kind
                           val term_has_var : var list -> 'a term -> bool
                           val pred_has_var : var list -> pred -> bool
                           val term_closed : 'a term -> bool
                           val pred_closed : pred -> bool
                           val p_forall : var list -> pred -> pred
                           val p_exists : var list -> pred -> pred
                           val p_subst :
                             (var -> var option) ->
                             var -> 'a term -> pred -> pred
                           val e_subst :
                             (var -> var option) ->
                             var -> 'a term -> 'b term -> 'b term
                           val e_rename :
                             (var * var) list -> 'a term -> 'a term
                           val equal_terms : 'a term -> 'a term -> bool
                           type alpha = D.F.alpha
                           val empty_alpha : alpha
                           val fold_alpha :
                             (var -> var -> '-> 'a) -> alpha -> '-> 'a
                           val p_more_alpha_cv :
                             alpha -> pred -> alpha * pred
                           val p_alpha_cv : pred -> var list * pred
                           val pp_var : Format.formatter -> var -> unit
                           val pp_term : Format.formatter -> 'a term -> unit
                           val pp_pred : Format.formatter -> pred -> unit
                           val pp_decl :
                             Format.formatter ->
                             pred Formula.declaration -> unit
                           val pp_goal :
                             Format.formatter -> string -> pred -> unit
                         end
                       type format = Formula.m_format F.term
                       type abstract = Formula.abstract F.term
                       type integer = Formula.integer F.term
                       type real = Formula.real F.term
                       type boolean = Formula.boolean F.term
                       type record = Formula.m_array F.term
                       type urecord = Formula.m_array F.term
                       type array = Formula.m_array F.term
                       type set = Formula.m_set F.term
                       type name = Formula.integer F.term
                       type pointer = Formula.m_pointer F.term
                       val pp_kind : Format.formatter -> Mdata.kind -> unit
                       type interval =
                         D.interval = {
                         inf : integer option;
                         sup : integer option;
                       }
                       type 'a assigned =
                         'D.assigned =
                           Aloc of Ctypes.c_object * 'a
                         | Arange of Ctypes.c_object * 'a * interval
                       val pp_interval : Format.formatter -> interval -> unit
                       val e_app0 : string -> 'F.term
                       val e_app1 : string -> 'F.term -> 'F.term
                       val e_app2 :
                         string -> 'F.term -> 'F.term -> 'F.term
                       val e_app3 :
                         string ->
                         'F.term -> 'F.term -> 'F.term -> 'F.term
                       val e_app4 :
                         string ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> 'F.term
                       val e_app5 :
                         string ->
                         'F.term ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> 'F.term
                       val p_app0 : string -> F.pred
                       val p_app1 : string -> 'F.term -> F.pred
                       val p_app2 :
                         string -> 'F.term -> 'F.term -> F.pred
                       val p_app3 :
                         string ->
                         'F.term -> 'F.term -> 'F.term -> F.pred
                       val p_app4 :
                         string ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> F.pred
                       val p_app5 :
                         string ->
                         'F.term ->
                         'F.term ->
                         'F.term -> 'F.term -> 'F.term -> F.pred
                       val tau_of_logic_type :
                         Cil_types.logic_type -> Formula.tau
                       type context = D.context
                       type bindings = D.bindings
                       class type hint =
                         object
                           method capture : F.var list -> unit
                           method has_var : F.var list -> bool
                           method pretty : Format.formatter -> unit
                           method subst :
                             F.var -> Formula.abstract F.term -> unit
                         end
                       val closed : bindings
                       val close : bindings -> F.pred -> F.pred
                       val capture : hint list -> bindings -> unit
                       val push :
                         string -> F.pool -> bindings -> hint list -> context
                       val pop : string -> context -> bindings
                       val kill : string -> context -> unit
                       val flush : string -> context -> F.pred -> F.pred
                       val term_such_that :
                         Formula.tau -> ('F.term -> F.pred) -> 'F.term
                       val forall : F.var list -> F.pred -> F.pred
                       val exists : F.var list -> F.pred -> F.pred
                       val subst : F.var -> 'F.term -> F.pred -> F.pred
                       val fresh : string -> Mdata.vkind -> F.var
                       val alpha : F.var -> F.var option
                       val pool : unit -> F.pool
                       val vkind_of_var : F.var -> Mdata.vkind
                       val has_vars : F.var list -> F.pred -> bool
                       type substitution = D.substitution
                       val apply : substitution -> 'F.term -> 'F.term
                       type havoc =
                         D.havoc =
                           Fresh of F.var
                         | Update of F.var *
                             (substitution -> Formula.abstract F.term)
                       val havoc_static : havoc list -> F.pred -> F.pred
                       val havoc_inductive : havoc list -> F.pred -> F.pred
                       val clear : unit -> unit
                       val on_clear : (unit -> unit) -> unit
                       val fresh_name : string -> string -> string
                       val add_declaration :
                         F.pred Formula.declaration -> unit
                       val iter :
                         Formula.section ->
                         (F.pred Formula.declaration -> unit) -> unit
                       val iter_all :
                         (F.pred Formula.declaration -> unit) -> unit
                       val dummy : unit -> F.pred
                       module type Identifiable =
                         sig
                           type t
                           module H : Hashtbl.S
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module type Registry =
                         sig
                           type t
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                         end
                       module type Declarator =
                         sig
                           type t
                           module H : Hashtbl.S
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                           val clear : unit -> unit
                           val section : Formula.section
                           val declare : t -> string -> F.pred Formula.item
                         end
                       module Register :
                         functor (D : Declarator->
                           sig
                             type t = D.t
                             val define : t -> unit
                             val get_definition :
                               t -> F.pred Formula.declaration
                             val on_definition :
                               (t -> F.pred Formula.declaration -> unit) ->
                               unit
                           end
                       module Varinfo :
                         sig
                           type t = Cil_types.varinfo
                           module H :
                             sig
                               type key = D.Varinfo.H.key
                               type 'a t = 'D.Varinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Varaddr :
                         sig
                           type t = Cil_types.varinfo
                           module H :
                             sig
                               type key = D.Varaddr.H.key
                               type 'a t = 'D.Varaddr.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Fieldinfo :
                         sig
                           type t = Cil_types.fieldinfo
                           module H :
                             sig
                               type key = D.Fieldinfo.H.key
                               type 'a t = 'D.Fieldinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Compinfo :
                         sig
                           type t = Cil_types.compinfo
                           module H :
                             sig
                               type key = D.Compinfo.H.key
                               type 'a t = 'D.Compinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Arrayinfo :
                         sig
                           type t = Ctypes.arrayinfo
                           module H :
                             sig
                               type key = D.Arrayinfo.H.key
                               type 'a t = 'D.Arrayinfo.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module Logicvar :
                         sig
                           type t = Cil_types.logic_var
                           module H :
                             sig
                               type key = D.Logicvar.H.key
                               type 'a t = 'D.Logicvar.H.t
                               val create : int -> 'a t
                               val clear : 'a t -> unit
                               val copy : 'a t -> 'a t
                               val add : 'a t -> key -> '-> unit
                               val remove : 'a t -> key -> unit
                               val find : 'a t -> key -> 'a
                               val find_all : 'a t -> key -> 'a list
                               val replace : 'a t -> key -> '-> unit
                               val mem : 'a t -> key -> bool
                               val iter : (key -> '-> unit) -> 'a t -> unit
                               val fold :
                                 (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                               val length : 'a t -> int
                             end
                           val index : t -> H.key
                           val prefix : string
                           val basename : t -> string
                           val location : t -> Log.source option
                           val pp_title : Format.formatter -> t -> unit
                           val pp_descr : Format.formatter -> t -> unit
                         end
                       module type Indexed =
                         sig
                           type t
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Dindex :
                         functor (I : Identifiable->
                           sig
                             type t = I.t
                             val define : t -> unit
                             val get_definition :
                               t -> F.pred Formula.declaration
                             val on_definition :
                               (t -> F.pred Formula.declaration -> unit) ->
                               unit
                             val get_ind : t -> integer
                           end
                       module Findex :
                         sig
                           type t = Cil_types.fieldinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Xindex :
                         sig
                           type t = Cil_types.varinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Aindex :
                         sig
                           type t = Cil_types.varinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       module Tindex :
                         sig
                           type t = Cil_types.compinfo
                           val define : t -> unit
                           val get_definition :
                             t -> F.pred Formula.declaration
                           val on_definition :
                             (t -> F.pred Formula.declaration -> unit) ->
                             unit
                           val get_ind : t -> integer
                         end
                       val modulo : Ctypes.c_int -> integer -> integer
                       val guard : Ctypes.c_int -> integer -> F.pred
                       val i_convert :
                         Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                       val round : Ctypes.c_float -> real -> real
                       val f_guard : Ctypes.c_float -> real -> F.pred
                       val f_convert :
                         Ctypes.c_float -> Ctypes.c_float -> real -> real
                       val has_type :
                         abstract -> Cil_types.logic_type -> F.pred
                       val get_range_index : array -> interval -> abstract
                       val set_range_index : array -> interval -> array
                       val empty : set
                       val singleton : abstract -> set
                       val union : set -> set -> set
                       val unions : set list -> set
                       val inter : set -> set -> set
                       val remove : set -> set -> set
                       val set_of_list : abstract list -> set
                       val add_set : set -> set -> set
                       val mult_set : set -> set -> set
                       val neg_set : set -> set
                       val interval : interval -> set
                       val equal_pointer_bool : pointer -> pointer -> boolean
                       val lt_pointer_bool : pointer -> pointer -> boolean
                       val le_pointer_bool : pointer -> pointer -> boolean
                       val lt_pointer : pointer -> pointer -> F.pred
                       val le_pointer : pointer -> pointer -> F.pred
                       val minus_pointer : pointer -> pointer -> integer
                       val is_null : pointer -> boolean
                       val null : pointer
                       val tau_of_object : Ctypes.c_object -> Formula.tau
                       val tau_of_ctype : Cil_types.typ -> Formula.tau
                       val int_format : format
                       val real_format : format
                       val pointer_format : format
                       val record_format : format
                       val urecord_format : format
                       val array_format : format -> format
                       val format_of_object : Ctypes.c_object -> format
                       val decode : format -> abstract -> 'F.term
                       val encode : format -> 'F.term -> abstract
                       val acc_field :
                         record -> Cil_types.fieldinfo -> abstract
                       val upd_field :
                         record -> Cil_types.fieldinfo -> abstract -> record
                       val acc_index : array -> integer -> abstract
                       val upd_index : array -> integer -> abstract -> array
                       val equal :
                         Ctypes.c_object -> abstract -> abstract -> F.pred
                       val eq_array :
                         Ctypes.arrayinfo -> array -> array -> F.pred
                       val eq_record :
                         Cil_types.compinfo -> record -> record -> F.pred
                     end
                   val f_neg : Ctypes.c_float -> D.real -> D.real
                   val f_op :
                     Ctypes.c_float ->
                     Formula.real_op -> D.real -> D.real -> D.real
                   val f_cmp :
                     Ctypes.c_float ->
                     Formula.cmp_op -> D.real -> D.real -> D.boolean
                 end
               type loc
               val loc_of_pointer : Ctypes.c_object -> D.pointer -> loc
               val pointer_of_loc : loc -> D.pointer
               val cast_loc_to_int :
                 Cil_types.typ -> loc -> Ctypes.c_int -> D.integer
               val cast_int_to_loc :
                 Ctypes.c_int -> D.integer -> Cil_types.typ -> loc
               val pp_loc : Format.formatter -> loc -> unit
               type value =
                   V_int of Ctypes.c_int * D.integer
                 | V_float of Ctypes.c_float * D.real
                 | V_pointer of Cil_types.typ * loc
                 | V_record of Cil_types.compinfo * D.record
                 | V_union of Cil_types.compinfo * D.urecord
                 | V_array of Ctypes.arrayinfo * D.array
               val pp_value : Format.formatter -> value -> unit
               val logic_of_value : value -> D.abstract
               val value_of_logic : Ctypes.c_object -> D.abstract -> value
               type mem
               val cvar : mem -> Cil_types.varinfo -> loc
               val shift : loc -> Ctypes.c_object -> D.integer -> loc
               val index : loc -> Ctypes.c_object -> D.integer -> loc
               val startof : loc -> Ctypes.c_object -> loc
               val field : loc -> Cil_types.fieldinfo -> loc
               val load : mem -> Ctypes.c_object -> loc -> value
               val cast_loc_to_loc :
                 Cil_types.typ -> Cil_types.typ -> loc -> loc
               type frame
               val new_frame :
                 Kernel_function.t ->
                 m_here:mem option ->
                 m_pre:mem option ->
                 m_post:mem option -> D.F.var option -> frame
               val mem_at : frame -> Clabels.c_label -> mem
               val result : frame -> D.F.var * Cil_types.typ
               val exit_status : frame -> D.F.var
               val set_exit_status : frame -> D.F.var -> frame
               val get_exit_status : frame -> D.F.var option
               val base_address : mem -> loc -> loc
               val block_length : mem -> loc -> Formula.integer D.F.term
               val valid : mem -> loc D.assigned -> D.F.pred
               val separated : loc D.assigned -> loc D.assigned -> D.F.pred
               type closure
               val userdef_frame : unit -> frame
               val userdef_signature :
                 frame ->
                 Formula.abstract D.F.term list ->
                 D.F.pred list -> D.F.var list * closure list
               val label_at_closure : closure -> string
               val userdef_closure :
                 mem -> closure -> Formula.abstract D.F.term
               val pp_closure : Format.formatter -> closure -> unit
               val update_at_label :
                 frame -> Clabels.c_label -> D.F.pred -> D.F.pred
               val quantify_at_label :
                 frame -> Clabels.c_label -> D.F.pred -> D.F.pred
               val subst_lval :
                 frame ->
                 Ctypes.c_object -> loc -> value -> D.F.pred -> D.F.pred
               val subst_result :
                 frame -> value option -> D.F.pred -> D.F.pred
               val subst_havoc : frame -> loc D.assigned -> D.havoc list
               val assigns_goal :
                 frame ->
                 Clabels.c_label ->
                 loc D.assigned list -> Clabels.c_label -> D.F.pred
               val assigns_supported : bool
               type m_dzone
               type dzone = m_dzone D.F.term
               val tau_of_dzone : Formula.tau
               val dzone_assigned : loc D.assigned -> dzone
               val dzone_subset : dzone -> dzone -> D.F.pred
               val dzone_union : dzone -> dzone -> dzone
               val dzone_empty : unit -> dzone
               val effect_supported : bool
               type region
               val pp_region : Format.formatter -> region -> unit
               val region_assigned : loc D.assigned -> region
               val region_empty : unit -> region
               val region_union : region -> region -> region
               val region_included : region -> region -> D.F.pred
               val region_separated : region -> region -> D.F.pred
               val region_fingerprint :
                 D.F.pool -> region -> D.F.var list * D.F.pred * region
               val region_supported : bool
               val local_scope :
                 frame ->
                 Cil_types.varinfo list -> Mcfg.scope -> D.F.pred -> D.F.pred
               val model : string
             end->
  sig
    module F :
      sig
        type 'a term = 'WpModel.D.F.term
        type pred = WpModel.D.F.pred
        val e_int : int -> Formula.integer term
        val e_call :
          string -> Formula.abstract term list -> Formula.abstract term
        val p_call : string -> Formula.abstract term list -> pred
        val wrap : 'a term -> Formula.abstract term
        val unwrap : Formula.abstract term -> 'a term
        val e_true : Formula.boolean term
        val e_false : Formula.boolean term
        val e_int : int -> Formula.integer term
        val e_float : float -> Formula.real term
        val e_icst : string -> Formula.integer term
        val e_rcst : string -> Formula.real term
        val e_int64 : int64 -> Formula.integer term
        val e_ineg : Formula.integer term -> Formula.integer term
        val e_rneg : Formula.real term -> Formula.real term
        val e_iop :
          Formula.integer_op ->
          Formula.integer term ->
          Formula.integer term -> Formula.integer term
        val e_rop :
          Formula.real_op ->
          Formula.real term -> Formula.real term -> Formula.real term
        val e_icmp :
          Formula.cmp_op ->
          Formula.integer term ->
          Formula.integer term -> Formula.boolean term
        val e_rcmp :
          Formula.cmp_op ->
          Formula.real term -> Formula.real term -> Formula.boolean term
        val p_icmp :
          Formula.cmp_op ->
          Formula.integer term -> Formula.integer term -> pred
        val p_rcmp :
          Formula.cmp_op -> Formula.real term -> Formula.real term -> pred
        val e_bnot : Formula.integer term -> Formula.integer term
        val e_band :
          Formula.integer term ->
          Formula.integer term -> Formula.integer term
        val e_bor :
          Formula.integer term ->
          Formula.integer term -> Formula.integer term
        val e_bxor :
          Formula.integer term ->
          Formula.integer term -> Formula.integer term
        val e_lshift :
          Formula.integer term ->
          Formula.integer term -> Formula.integer term
        val e_rshift :
          Formula.integer term ->
          Formula.integer term -> Formula.integer term
        val integer_of_real : Formula.real term -> Formula.integer term
        val real_of_integer : Formula.integer term -> Formula.real term
        val e_bool : Formula.boolean term -> Formula.integer term
        val e_not : Formula.boolean term -> Formula.boolean term
        val e_and :
          Formula.boolean term ->
          Formula.boolean term -> Formula.boolean term
        val e_or :
          Formula.boolean term ->
          Formula.boolean term -> Formula.boolean term
        val e_cond : Formula.boolean term -> 'a term -> 'a term -> 'a term
        val p_cond : Formula.boolean term -> pred -> pred -> pred
        val p_true : pred
        val p_false : pred
        val p_bool : Formula.boolean term -> pred
        val p_and : pred -> pred -> pred
        val p_or : pred -> pred -> pred
        val p_xor : pred -> pred -> pred
        val p_not : pred -> pred
        val p_implies : pred -> pred -> pred
        val p_iff : pred -> pred -> pred
        val p_eq : 'a term -> 'a term -> pred
        val p_neq : 'a term -> 'a term -> pred
        val p_conj : pred list -> pred
        val p_disj : pred list -> pred
        val p_named : string -> pred -> pred
        val is_true : pred -> bool
        val is_false : pred -> bool
        val huge_term : int -> 'a term -> bool
        val huge_pred : int -> pred -> bool
        type var = WpModel.D.F.var
        type pool = WpModel.D.F.pool
        val pool : unit -> pool
        val fresh : pool -> string -> Formula.kind -> var
        val freshen : pool -> var -> var
        val var : var -> 'a term
        val eq_var : var -> var -> bool
        val name_of_var : var -> string
        val tau_of_var : var -> Formula.tau
        val kind_of_var : var -> Formula.kind
        val term_has_var : var list -> 'a term -> bool
        val pred_has_var : var list -> pred -> bool
        val term_closed : 'a term -> bool
        val pred_closed : pred -> bool
        val p_forall : var list -> pred -> pred
        val p_exists : var list -> pred -> pred
        val p_subst : (var -> var option) -> var -> 'a term -> pred -> pred
        val e_subst :
          (var -> var option) -> var -> 'a term -> 'b term -> 'b term
        val e_rename : (var * var) list -> 'a term -> 'a term
        val equal_terms : 'a term -> 'a term -> bool
        type alpha = WpModel.D.F.alpha
        val empty_alpha : alpha
        val fold_alpha : (var -> var -> '-> 'a) -> alpha -> '-> 'a
        val p_more_alpha_cv : alpha -> pred -> alpha * pred
        val p_alpha_cv : pred -> var list * pred
        val pp_var : Format.formatter -> var -> unit
        val pp_term : Format.formatter -> 'a term -> unit
        val pp_pred : Format.formatter -> pred -> unit
        val pp_decl : Format.formatter -> pred Formula.declaration -> unit
        val pp_goal : Format.formatter -> string -> pred -> unit
      end
    module D :
      sig
        module F :
          sig
            type 'a term = 'WpModel.D.F.term
            type pred = WpModel.D.F.pred
            val e_int : int -> Formula.integer term
            val e_call :
              string -> Formula.abstract term list -> Formula.abstract term
            val p_call : string -> Formula.abstract term list -> pred
            val wrap : 'a term -> Formula.abstract term
            val unwrap : Formula.abstract term -> 'a term
            val e_true : Formula.boolean term
            val e_false : Formula.boolean term
            val e_int : int -> Formula.integer term
            val e_float : float -> Formula.real term
            val e_icst : string -> Formula.integer term
            val e_rcst : string -> Formula.real term
            val e_int64 : int64 -> Formula.integer term
            val e_ineg : Formula.integer term -> Formula.integer term
            val e_rneg : Formula.real term -> Formula.real term
            val e_iop :
              Formula.integer_op ->
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_rop :
              Formula.real_op ->
              Formula.real term -> Formula.real term -> Formula.real term
            val e_icmp :
              Formula.cmp_op ->
              Formula.integer term ->
              Formula.integer term -> Formula.boolean term
            val e_rcmp :
              Formula.cmp_op ->
              Formula.real term -> Formula.real term -> Formula.boolean term
            val p_icmp :
              Formula.cmp_op ->
              Formula.integer term -> Formula.integer term -> pred
            val p_rcmp :
              Formula.cmp_op ->
              Formula.real term -> Formula.real term -> pred
            val e_bnot : Formula.integer term -> Formula.integer term
            val e_band :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_bor :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_bxor :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_lshift :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_rshift :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val integer_of_real : Formula.real term -> Formula.integer term
            val real_of_integer : Formula.integer term -> Formula.real term
            val e_bool : Formula.boolean term -> Formula.integer term
            val e_not : Formula.boolean term -> Formula.boolean term
            val e_and :
              Formula.boolean term ->
              Formula.boolean term -> Formula.boolean term
            val e_or :
              Formula.boolean term ->
              Formula.boolean term -> Formula.boolean term
            val e_cond :
              Formula.boolean term -> 'a term -> 'a term -> 'a term
            val p_cond : Formula.boolean term -> pred -> pred -> pred
            val p_true : pred
            val p_false : pred
            val p_bool : Formula.boolean term -> pred
            val p_and : pred -> pred -> pred
            val p_or : pred -> pred -> pred
            val p_xor : pred -> pred -> pred
            val p_not : pred -> pred
            val p_implies : pred -> pred -> pred
            val p_iff : pred -> pred -> pred
            val p_eq : 'a term -> 'a term -> pred
            val p_neq : 'a term -> 'a term -> pred
            val p_conj : pred list -> pred
            val p_disj : pred list -> pred
            val p_named : string -> pred -> pred
            val is_true : pred -> bool
            val is_false : pred -> bool
            val huge_term : int -> 'a term -> bool
            val huge_pred : int -> pred -> bool
            type var = WpModel.D.F.var
            type pool = WpModel.D.F.pool
            val pool : unit -> pool
            val fresh : pool -> string -> Formula.kind -> var
            val freshen : pool -> var -> var
            val var : var -> 'a term
            val eq_var : var -> var -> bool
            val name_of_var : var -> string
            val tau_of_var : var -> Formula.tau
            val kind_of_var : var -> Formula.kind
            val term_has_var : var list -> 'a term -> bool
            val pred_has_var : var list -> pred -> bool
            val term_closed : 'a term -> bool
            val pred_closed : pred -> bool
            val p_forall : var list -> pred -> pred
            val p_exists : var list -> pred -> pred
            val p_subst :
              (var -> var option) -> var -> 'a term -> pred -> pred
            val e_subst :
              (var -> var option) -> var -> 'a term -> 'b term -> 'b term
            val e_rename : (var * var) list -> 'a term -> 'a term
            val equal_terms : 'a term -> 'a term -> bool
            type alpha = WpModel.D.F.alpha
            val empty_alpha : alpha
            val fold_alpha : (var -> var -> '-> 'a) -> alpha -> '-> 'a
            val p_more_alpha_cv : alpha -> pred -> alpha * pred
            val p_alpha_cv : pred -> var list * pred
            val pp_var : Format.formatter -> var -> unit
            val pp_term : Format.formatter -> 'a term -> unit
            val pp_pred : Format.formatter -> pred -> unit
            val pp_decl :
              Format.formatter -> pred Formula.declaration -> unit
            val pp_goal : Format.formatter -> string -> pred -> unit
          end
        type format = Formula.m_format F.term
        type abstract = Formula.abstract F.term
        type integer = Formula.integer F.term
        type real = Formula.real F.term
        type boolean = Formula.boolean F.term
        type record = Formula.m_array F.term
        type urecord = Formula.m_array F.term
        type array = Formula.m_array F.term
        type set = Formula.m_set F.term
        type name = Formula.integer F.term
        type pointer = Formula.m_pointer F.term
        val pp_kind : Format.formatter -> Mdata.kind -> unit
        type interval =
          WpModel.D.interval = {
          inf : integer option;
          sup : integer option;
        }
        type 'a assigned =
          'WpModel.D.assigned =
            Aloc of Ctypes.c_object * 'a
          | Arange of Ctypes.c_object * 'a * interval
        val pp_interval : Format.formatter -> interval -> unit
        val e_app0 : string -> 'F.term
        val e_app1 : string -> 'F.term -> 'F.term
        val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
        val e_app3 :
          string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
        val e_app4 :
          string ->
          'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
        val e_app5 :
          string ->
          'F.term ->
          'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
        val p_app0 : string -> F.pred
        val p_app1 : string -> 'F.term -> F.pred
        val p_app2 : string -> 'F.term -> 'F.term -> F.pred
        val p_app3 : string -> 'F.term -> 'F.term -> 'F.term -> F.pred
        val p_app4 :
          string ->
          'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
        val p_app5 :
          string ->
          'F.term ->
          'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
        val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
        type context = WpModel.D.context
        type bindings = WpModel.D.bindings
        class type hint =
          object
            method capture : F.var list -> unit
            method has_var : F.var list -> bool
            method pretty : Format.formatter -> unit
            method subst : F.var -> Formula.abstract F.term -> unit
          end
        val closed : bindings
        val close : bindings -> F.pred -> F.pred
        val capture : hint list -> bindings -> unit
        val push : string -> F.pool -> bindings -> hint list -> context
        val pop : string -> context -> bindings
        val kill : string -> context -> unit
        val flush : string -> context -> F.pred -> F.pred
        val term_such_that :
          Formula.tau -> ('F.term -> F.pred) -> 'F.term
        val forall : F.var list -> F.pred -> F.pred
        val exists : F.var list -> F.pred -> F.pred
        val subst : F.var -> 'F.term -> F.pred -> F.pred
        val fresh : string -> Mdata.vkind -> F.var
        val alpha : F.var -> F.var option
        val pool : unit -> F.pool
        val vkind_of_var : F.var -> Mdata.vkind
        val has_vars : F.var list -> F.pred -> bool
        type substitution = WpModel.D.substitution
        val apply : substitution -> 'F.term -> 'F.term
        type havoc =
          WpModel.D.havoc =
            Fresh of F.var
          | Update of F.var * (substitution -> Formula.abstract F.term)
        val havoc_static : havoc list -> F.pred -> F.pred
        val havoc_inductive : havoc list -> F.pred -> F.pred
        val clear : unit -> unit
        val on_clear : (unit -> unit) -> unit
        val fresh_name : string -> string -> string
        val add_declaration : F.pred Formula.declaration -> unit
        val iter :
          Formula.section -> (F.pred Formula.declaration -> unit) -> unit
        val iter_all : (F.pred Formula.declaration -> unit) -> unit
        val dummy : unit -> F.pred
        module type Identifiable =
          sig
            type t
            module H : Hashtbl.S
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module type Registry =
          sig
            type t
            val define : t -> unit
            val get_definition : t -> F.pred Formula.declaration
            val on_definition :
              (t -> F.pred Formula.declaration -> unit) -> unit
          end
        module type Declarator =
          sig
            type t
            module H : Hashtbl.S
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
            val clear : unit -> unit
            val section : Formula.section
            val declare : t -> string -> F.pred Formula.item
          end
        module Register :
          functor (D : Declarator->
            sig
              type t = D.t
              val define : t -> unit
              val get_definition : t -> F.pred Formula.declaration
              val on_definition :
                (t -> F.pred Formula.declaration -> unit) -> unit
            end
        module Varinfo :
          sig
            type t = Cil_types.varinfo
            module H :
              sig
                type key = WpModel.D.Varinfo.H.key
                type 'a t = 'WpModel.D.Varinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Varaddr :
          sig
            type t = Cil_types.varinfo
            module H :
              sig
                type key = WpModel.D.Varaddr.H.key
                type 'a t = 'WpModel.D.Varaddr.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Fieldinfo :
          sig
            type t = Cil_types.fieldinfo
            module H :
              sig
                type key = WpModel.D.Fieldinfo.H.key
                type 'a t = 'WpModel.D.Fieldinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Compinfo :
          sig
            type t = Cil_types.compinfo
            module H :
              sig
                type key = WpModel.D.Compinfo.H.key
                type 'a t = 'WpModel.D.Compinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Arrayinfo :
          sig
            type t = Ctypes.arrayinfo
            module H :
              sig
                type key = WpModel.D.Arrayinfo.H.key
                type 'a t = 'WpModel.D.Arrayinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Logicvar :
          sig
            type t = Cil_types.logic_var
            module H :
              sig
                type key = WpModel.D.Logicvar.H.key
                type 'a t = 'WpModel.D.Logicvar.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Log.source option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module type Indexed =
          sig
            type t
            val define : t -> unit
            val get_definition : t -> F.pred Formula.declaration
            val on_definition :
              (t -> F.pred Formula.declaration -> unit) -> unit
            val get_ind : t -> integer
          end
        module Dindex :
          functor (I : Identifiable->
            sig
              type t = I.t
              val define : t -> unit
              val get_definition : t -> F.pred Formula.declaration
              val on_definition :
                (t -> F.pred Formula.declaration -> unit) -> unit
              val get_ind : t -> integer
            end
        module Findex :
          sig
            type t = Cil_types.fieldinfo
            val define : t -> unit
            val get_definition : t -> F.pred Formula.declaration
            val on_definition :
              (t -> F.pred Formula.declaration -> unit) -> unit
            val get_ind : t -> integer
          end
        module Xindex :
          sig
            type t = Cil_types.varinfo
            val define : t -> unit
            val get_definition : t -> F.pred Formula.declaration
            val on_definition :
              (t -> F.pred Formula.declaration -> unit) -> unit
            val get_ind : t -> integer
          end
        module Aindex :
          sig
            type t = Cil_types.varinfo
            val define : t -> unit
            val get_definition : t -> F.pred Formula.declaration
            val on_definition :
              (t -> F.pred Formula.declaration -> unit) -> unit
            val get_ind : t -> integer
          end
        module Tindex :
          sig
            type t = Cil_types.compinfo
            val define : t -> unit
            val get_definition : t -> F.pred Formula.declaration
            val on_definition :
              (t -> F.pred Formula.declaration -> unit) -> unit
            val get_ind : t -> integer
          end
        val modulo : Ctypes.c_int -> integer -> integer
        val guard : Ctypes.c_int -> integer -> F.pred
        val i_convert : Ctypes.c_int -> Ctypes.c_int -> integer -> integer
        val round : Ctypes.c_float -> real -> real
        val f_guard : Ctypes.c_float -> real -> F.pred
        val f_convert : Ctypes.c_float -> Ctypes.c_float -> real -> real
        val has_type : abstract -> Cil_types.logic_type -> F.pred
        val get_range_index : array -> interval -> abstract
        val set_range_index : array -> interval -> array
        val empty : set
        val singleton : abstract -> set
        val union : set -> set -> set
        val unions : set list -> set
        val inter : set -> set -> set
        val remove : set -> set -> set
        val set_of_list : abstract list -> set
        val add_set : set -> set -> set
        val mult_set : set -> set -> set
        val neg_set : set -> set
        val interval : interval -> set
        val equal_pointer_bool : pointer -> pointer -> boolean
        val lt_pointer_bool : pointer -> pointer -> boolean
        val le_pointer_bool : pointer -> pointer -> boolean
        val lt_pointer : pointer -> pointer -> F.pred
        val le_pointer : pointer -> pointer -> F.pred
        val minus_pointer : pointer -> pointer -> integer
        val is_null : pointer -> boolean
        val null : pointer
        val tau_of_object : Ctypes.c_object -> Formula.tau
        val tau_of_ctype : Cil_types.typ -> Formula.tau
        val int_format : format
        val real_format : format
        val pointer_format : format
        val record_format : format
        val urecord_format : format
        val array_format : format -> format
        val format_of_object : Ctypes.c_object -> format
        val decode : format -> abstract -> 'F.term
        val encode : format -> 'F.term -> abstract
        val acc_field : record -> Cil_types.fieldinfo -> abstract
        val upd_field : record -> Cil_types.fieldinfo -> abstract -> record
        val acc_index : array -> integer -> abstract
        val upd_index : array -> integer -> abstract -> array
        val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
        val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
        val eq_record : Cil_types.compinfo -> record -> record -> F.pred
      end
    module E :
      sig
        val addr : WpModel.mem -> Cil_types.lval -> WpModel.loc
        val expr : WpModel.mem -> Cil_types.exp -> WpModel.value
        val cond :
          WpModel.mem -> Cil_types.exp -> Formula.boolean WpModel.D.F.term
        val prop : WpModel.mem -> Cil_types.exp -> WpModel.D.F.pred
        val expr_cast :
          Cil_types.typ -> Cil_types.typ -> WpModel.value -> WpModel.value
      end
    module L :
      sig
        type env = Translate_prop.Create(WpModel).env
        val env_body : WpModel.frame -> env
        val env_at : env -> Clabels.c_label -> env
        val call_post :
          Kernel_function.t ->
          WpModel.value list ->
          WpModel.mem -> WpModel.mem -> WpModel.D.F.var option -> env
        val call_pre :
          Kernel_function.t -> WpModel.value list -> WpModel.mem -> env
        val call_exit : env -> WpModel.D.F.var -> env
        val assigns_clause : WpModel.frame -> env
        val get_frame : env -> WpModel.frame
        val term : env -> Cil_types.term -> Formula.abstract WpModel.D.F.term
        val prop :
          env -> Cil_types.predicate Cil_types.named -> WpModel.D.F.pred
        val assigned :
          env -> Cil_types.term -> WpModel.loc WpModel.D.assigned list
        val add_axiom :
          string ->
          Cil_types.logic_label list ->
          Cil_types.predicate Cil_types.named -> unit
        type instance = Translate_prop.Create(WpModel).instance
        val as_hint : instance -> WpModel.D.hint
        val push_instances : string -> instance list -> unit
        val pop_instances : string -> instance list
        val instantiate :
          instance list ->
          WpModel.D.F.pred -> instance list * WpModel.D.F.pred
        val merge : instance list -> instance list -> instance list
      end
    val predicate :
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.predicate Cil_types.named -> WpModel.D.F.pred Wp_error.cc
    val expr : WpModel.mem -> Cil_types.exp -> WpModel.value Wp_error.cc
    val addr : WpModel.mem -> Cil_types.lval -> WpModel.loc Wp_error.cc
    val cond : WpModel.mem -> Cil_types.exp -> WpModel.D.F.pred Wp_error.cc
    val cast :
      Cil_types.typ ->
      Cil_types.typ -> WpModel.value -> WpModel.value Wp_error.cc
    type t_env =
        CfgWeakestPrecondition.Create.F.pool *
        CfgWeakestPrecondition.Create.L.env
    type t_prop =
        CfgWeakestPrecondition.Create.assigns_kind *
        CfgWeakestPrecondition.Create.property
    and property = {
      bindings : CfgWeakestPrecondition.Create.D.bindings;
      instances : CfgWeakestPrecondition.Create.L.instance list;
      property : CfgWeakestPrecondition.Create.F.pred;
    }
    and assigns_kind =
        NoAssigns
      | EffectAssigns of CfgWeakestPrecondition.Create.effect_assigns
      | RegionAssigns of CfgWeakestPrecondition.Create.region_assigns
    and effect_assigns = {
      a_pid : WpAnnot.prop_id;
      a_label : Clabels.c_label;
      a_effect : CfgWeakestPrecondition.Create.F.var;
      a_locals : CfgWeakestPrecondition.Create.F.var;
    }
    and region_assigns = {
      r_pid : WpAnnot.prop_id;
      r_vars : CfgWeakestPrecondition.Create.F.var list;
      r_global : WpModel.region;
      r_label : Clabels.c_label;
      mutable r_effect : int;
      mutable r_locals :
        (Cil_types.varinfo list * CfgWeakestPrecondition.Create.F.var list *
         WpModel.region)
        list;
    }
    val empty :
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property
    val zip :
      'a * CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.D.F.pred
    val merge_assigns :
      CfgWeakestPrecondition.Create.assigns_kind ->
      CfgWeakestPrecondition.Create.assigns_kind ->
      CfgWeakestPrecondition.Create.assigns_kind
    val merge_property :
      (CfgWeakestPrecondition.Create.D.F.pred ->
       CfgWeakestPrecondition.Create.D.F.pred ->
       CfgWeakestPrecondition.Create.F.pred) ->
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.property
    val merge :
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property
    val pretty :
      Format.formatter -> 'a * CfgWeakestPrecondition.Create.property -> unit
    val new_env :
      Kernel_function.t ->
      CfgWeakestPrecondition.Create.F.pool *
      CfgWeakestPrecondition.Create.L.env
    type closing = Keep_opened | Apply_hints | Close_context
    type assigns =
        Keep_assigns
      | Clear_assigns
      | Label_assigns of Clabels.c_label
      | Goal_assigns of
          CfgWeakestPrecondition.Create.assigns_kind Pervasives.ref
    val pp_vars : Format.formatter -> Cil_types.varinfo list -> unit
    val region_assigns : int -> CfgWeakestPrecondition.Create.D.F.pred
    val region_included :
      WpModel.region ->
      CfgWeakestPrecondition.Create.region_assigns ->
      CfgWeakestPrecondition.Create.F.pred
    val close_property :
      string ->
      CfgWeakestPrecondition.Create.D.context ->
      CfgWeakestPrecondition.Create.F.pred ->
      CfgWeakestPrecondition.Create.closing ->
      CfgWeakestPrecondition.Create.property
    exception Failed
    val on_context :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      string ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.closing ->
      CfgWeakestPrecondition.Create.assigns ->
      (CfgWeakestPrecondition.Create.L.env ->
       CfgWeakestPrecondition.Create.assigns_kind ->
       CfgWeakestPrecondition.Create.F.pred ->
       CfgWeakestPrecondition.Create.F.pred) ->
      CfgWeakestPrecondition.Create.t_prop
    val label :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.logic_label ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val merge_with :
      (CfgWeakestPrecondition.Create.D.F.pred ->
       CfgWeakestPrecondition.Create.D.F.pred ->
       CfgWeakestPrecondition.Create.F.pred) ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property
    val add_as_hyp :
      '->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property
    val add_as_goal :
      '->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property
    val add_hyp :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      WpAnnot.prop_id ->
      Cil_types.predicate Cil_types.named ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val add_goal :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      WpAnnot.prop_id ->
      Cil_types.predicate Cil_types.named ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val add_axiom :
      '->
      string ->
      Cil_types.logic_label list ->
      Cil_types.predicate Cil_types.named -> unit
    val assign :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.lval ->
      Cil_types.exp ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val return :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.exp option ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val test :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.exp ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val case_of_exp :
      WpModel.mem ->
      Cil_types.exp -> Formula.integer CfgWeakestPrecondition.Create.F.term
    val switch :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.exp ->
      (Cil_types.exp list *
       (CfgWeakestPrecondition.Create.assigns_kind *
        CfgWeakestPrecondition.Create.property))
      list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val scope :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.varinfo list ->
      Mcfg.scope ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val build_prop_of_from :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      (WpAnnot.prop_id * Cil_types.predicate Cil_types.named) list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val close :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val translate_assigned_targets :
      CfgWeakestPrecondition.Create.L.env ->
      Cil_types.term list -> WpModel.loc WpModel.D.assigned list Wp_error.cc
    val translate_assigned :
      CfgWeakestPrecondition.Create.L.env ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      WpModel.loc WpModel.D.assigned list Wp_error.cc
    val assigned_of_assigns :
      CfgWeakestPrecondition.Create.L.env ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      WpModel.loc WpModel.D.assigned list option
    val assigned_for_assigns_goal :
      WpAnnot.a_kind ->
      Clabels.c_label ->
      CfgWeakestPrecondition.Create.L.env ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      WpModel.loc WpModel.D.assigned list
    val havoc_region :
      WpAnnot.a_kind ->
      WpModel.frame ->
      WpModel.loc WpModel.D.assigned list option ->
      CfgWeakestPrecondition.Create.D.F.pred ->
      CfgWeakestPrecondition.Create.D.F.pred
    val assigns_method : unit -> Mcfg.assigns_method
    val add_normal_assigns :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      WpAnnot.prop_id ->
      Cil_types.logic_label ->
      WpAnnot.a_kind ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val add_effect_assigns :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      WpAnnot.prop_id ->
      Cil_types.logic_label ->
      WpAnnot.a_kind ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val add_region_assigns :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      WpAnnot.prop_id ->
      Cil_types.logic_label ->
      WpAnnot.a_kind ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val add_assigns :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      WpAnnot.prop_id ->
      Cil_types.logic_label ->
      WpAnnot.a_kind ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val check_assigns :
      CfgWeakestPrecondition.Create.assigns_kind ->
      WpModel.loc WpModel.D.assigned list option ->
      CfgWeakestPrecondition.Create.D.F.pred ->
      CfgWeakestPrecondition.Create.D.F.pred
    val use_assigns :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      WpAnnot.prop_id ->
      WpAnnot.a_kind ->
      (Cil_types.identified_term Cil_types.zone * 'a) list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val call :
      CfgWeakestPrecondition.Create.L.env ->
      get_pre:(Db_types.kernel_function ->
               ('a * Cil_types.predicate Cil_types.named) list) ->
      get_post:(Db_types.kernel_function ->
                ('b * Cil_types.predicate Cil_types.named) list) ->
      get_exits:(Db_types.kernel_function ->
                 ('c * Cil_types.predicate Cil_types.named) list) ->
      get_assigns:(Db_types.kernel_function ->
                   (Cil_types.identified_term Cil_types.zone * 'd) list) ->
      Cil_types.stmt ->
      Cil_types.lval option ->
      Cil_types.exp ->
      Cil_types.exp list ->
      CfgWeakestPrecondition.Create.assigns_kind ->
      CfgWeakestPrecondition.Create.F.pred ->
      CfgWeakestPrecondition.Create.F.pred ->
      WpModel.D.F.pred * WpModel.D.F.pred
    val call_normal :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      get_pre:(Db_types.kernel_function ->
               ('a * Cil_types.predicate Cil_types.named) list) ->
      get_post:(Db_types.kernel_function ->
                ('b * Cil_types.predicate Cil_types.named) list) ->
      get_assigns:(Db_types.kernel_function ->
                   (Cil_types.identified_term Cil_types.zone * 'c) list) ->
      Cil_types.stmt ->
      Cil_types.lval option ->
      Cil_types.exp ->
      Cil_types.exp list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
    val call_exit :
      CfgWeakestPrecondition.Create.D.F.pool *
      CfgWeakestPrecondition.Create.L.env ->
      get_pre:(Db_types.kernel_function ->
               ('a * Cil_types.predicate Cil_types.named) list) ->
      get_exits:(Db_types.kernel_function ->
                 ('b * Cil_types.predicate Cil_types.named) list) ->
      get_assigns:(Db_types.kernel_function ->
                   (Cil_types.identified_term Cil_types.zone * 'c) list) ->
      Cil_types.stmt ->
      Cil_types.exp ->
      Cil_types.exp list ->
      CfgWeakestPrecondition.Create.assigns_kind *
      CfgWeakestPrecondition.Create.property ->
      CfgWeakestPrecondition.Create.t_prop
  end