functor (V : Mvalues.Values->
  sig
    module F :
      sig
        type var = V.F.var
        type 'a term = 'V.F.term
        type pred = V.F.pred
        type abstract = Formula.m_abstract term
        type integer = Formula.m_integer term
        type real = Formula.m_real term
        type boolean = Formula.m_boolean term
        type record = Formula.m_record term
        type urecord = Formula.m_array term
        type array = Formula.m_array term
        type set = Formula.m_set term
        type name = Formula.m_integer term
        type decl = (var, abstract, pred) Formula.declaration
        val e_int : int -> integer
        val e_call : string -> abstract list -> abstract
        val p_call : string -> abstract list -> pred
        val wrap : 'a term -> abstract
        val unwrap : abstract -> 'a term
        val clear : unit -> unit
        val on_clear : (unit -> unit) -> unit
        val fresh_name : string -> string -> string
        val add_declaration : decl -> unit
        val has_declaration : string -> bool
        val iter_all : (string -> unit) -> (decl -> unit) -> unit
        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 -> Lexing.position 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 -> decl
            val on_definition : (t -> decl -> 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 -> Lexing.position 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 -> (var, abstract, pred) Formula.item
          end
        module DRegister :
          functor (D : Declarator->
            sig
              type t = D.t
              val define : t -> unit
              val get_definition : t -> decl
              val on_definition : (t -> decl -> unit) -> unit
            end
        module Varinfo :
          sig
            type t = Cil_types.varinfo
            module H :
              sig
                type key = V.F.Varinfo.H.key
                type 'a t = 'V.F.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 -> Lexing.position 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 = V.F.Varaddr.H.key
                type 'a t = 'V.F.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 -> Lexing.position 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 = V.F.Fieldinfo.H.key
                type 'a t = 'V.F.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 -> Lexing.position 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 = V.F.Compinfo.H.key
                type 'a t = 'V.F.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 -> Lexing.position 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 = V.F.Arrayinfo.H.key
                type 'a t = 'V.F.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 -> Lexing.position 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 = V.F.Logicvar.H.key
                type 'a t = 'V.F.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 -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module LTypeinfo :
          sig
            type t = Cil_types.logic_type
            module H :
              sig
                type key = V.F.LTypeinfo.H.key
                type 'a t = 'V.F.LTypeinfo.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 -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Cobject :
          sig
            type t = Ctypes.c_object
            module H :
              sig
                type key = V.F.Cobject.H.key
                type 'a t = 'V.F.Cobject.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 -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module ArrayDim :
          sig
            type t = Ctypes.c_object * int
            module H :
              sig
                type key = V.F.ArrayDim.H.key
                type 'a t = 'V.F.ArrayDim.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 -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        val adt_decl : Cil_types.logic_type_info -> string
        val pp_tau : Format.formatter -> Formula.tau -> unit
        val e_true : boolean
        val e_false : boolean
        val e_float : float -> real
        val e_icst : string -> integer
        val e_rcst : string -> real
        val e_int64 : int64 -> integer
        val e_ineg : integer -> integer
        val e_rneg : real -> real
        val e_iop : Formula.int_op -> integer -> integer -> integer
        val e_rop : Formula.real_op -> real -> real -> real
        val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
        val e_rcmp : Formula.cmp_op -> real -> real -> boolean
        val p_icmp : Formula.cmp_op -> integer -> integer -> pred
        val p_rcmp : Formula.cmp_op -> real -> real -> pred
        val e_bnot : integer -> integer
        val e_band : integer -> integer -> integer
        val e_bor : integer -> integer -> integer
        val e_bxor : integer -> integer -> integer
        val e_lshift : integer -> integer -> integer
        val e_rshift : integer -> integer -> integer
        val integer_of_real : real -> integer
        val real_of_integer : integer -> real
        val e_bool : boolean -> integer
        val e_not : boolean -> boolean
        val e_and : boolean -> boolean -> boolean
        val e_or : boolean -> boolean -> boolean
        val e_cond : boolean -> 'a term -> 'a term -> 'a term
        val p_cond : boolean -> pred -> pred -> pred
        val e_getfield : Cil_types.fieldinfo -> record -> abstract
        val e_setfield : Cil_types.fieldinfo -> record -> abstract -> record
        val e_access : array -> integer -> abstract
        val e_update : array -> integer -> abstract -> array
        val p_true : pred
        val p_false : pred
        val p_bool : boolean -> 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 pool = V.F.pool
        val pool : unit -> pool
        val p_fresh : pool -> string -> Formula.kind -> var
        val p_freshen : pool -> var -> var
        val var : var -> 'a term
        val eq_var : var -> var -> bool
        val name_of_var : var -> string
        val basename_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_calls : string -> 'a term -> bool
        val pred_calls : string -> pred -> bool
        val term_closed : 'a term -> bool
        val pred_closed : pred -> bool
        val freevars : pred -> var list
        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 = V.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_section : Format.formatter -> string -> unit
        val pp_term : Format.formatter -> 'a term -> unit
        val pp_pred : Format.formatter -> pred -> unit
        val pp_decl : Format.formatter -> decl -> unit
        val pp_goal : Format.formatter -> string -> pred -> unit
        val pp_vkind : Format.formatter -> Formula.kind -> unit
        val e_app0 : string -> 'a term
        val e_app1 : string -> 'a term -> 'b term
        val e_app2 : string -> 'a term -> 'b term -> 'c term
        val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
        val e_app4 :
          string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
        val e_app5 :
          string ->
          'a term -> 'b term -> 'c term -> 'd term -> 'e term -> 'f term
        val p_app0 : string -> pred
        val p_app1 : string -> 'a term -> pred
        val p_app2 : string -> 'a term -> 'b term -> pred
        val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
        val p_app4 :
          string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
        val p_app5 :
          string ->
          'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
        val dummy : unit -> pred
        val i_zero : integer
        val r_zero : real
        val i_one : integer
        val i_add : integer -> integer -> integer
        val i_mult : integer -> integer -> integer
        val i_sub : integer -> integer -> integer
        val guard : Ctypes.c_int -> integer -> pred
        val modulo : Ctypes.c_int -> integer -> integer
        val i_convert : Ctypes.c_int -> Ctypes.c_int -> integer -> integer
        type interval =
          V.F.interval = {
          inf : integer option;
          sup : integer option;
        }
        type 'a assigned =
          'V.F.assigned =
            Aloc of Ctypes.c_object * 'a
          | Arange of Ctypes.c_object * 'a * interval
        type havoc =
          V.F.havoc =
            Fresh of var
          | Update of var * ((var * var) list -> abstract)
        val pp_interval : Format.formatter -> interval -> unit
        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 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
        module type Indexed =
          sig
            type t
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Dindex :
          functor (I : Identifiable->
            sig
              type t = I.t
              val define : t -> unit
              val get_definition : t -> decl
              val on_definition : (t -> decl -> unit) -> unit
              val get_ind : t -> integer
              val has_ind : t -> pred -> bool
            end
        module Findex :
          sig
            type t = Cil_types.fieldinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Xindex :
          sig
            type t = Cil_types.varinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Aindex :
          sig
            type t = Cil_types.varinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Tindex :
          sig
            type t = Cil_types.compinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module LTindex :
          sig
            type t = Cil_types.logic_type
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
      end
    type context
    type bindings
    val closed : bindings
    val close : bindings -> F.pred -> F.pred
    val push : string -> F.pool -> bindings -> 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 -> Formula.kind -> F.var
    val alpha : F.var -> F.var option
    val pool : unit -> F.pool
    val vkind_of_var : F.var -> Formula.kind
    val has_context_vars : F.var list -> F.pred -> bool
    val has_type : F.abstract -> Cil_types.logic_type -> F.pred
    val is_comp : Cil_types.compinfo -> F.abstract -> F.pred
    val is_array : Ctypes.arrayinfo -> F.abstract -> F.pred
    val apply : (F.var * F.var) list -> 'F.term -> 'F.term
    val havoc_static : F.havoc list -> F.pred -> F.pred
    val havoc_inductive : F.havoc list -> F.pred -> F.pred
  end