functor (M : Mwp.S->
  sig
    module Lookup :
      sig
        module F :
          sig
            type 'a term = 'M.D.F.term
            type pred = M.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 = M.D.F.var
            type pool = M.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 = M.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 = 'M.D.F.term
                type pred = M.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 = M.D.F.var
                type pool = M.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 = M.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 =
              M.D.interval = {
              inf : integer option;
              sup : integer option;
            }
            type 'a assigned =
              'M.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 = M.D.context
            type bindings = M.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 = M.D.substitution
            val apply : substitution -> 'F.term -> 'F.term
            type havoc =
              M.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 = M.D.Varinfo.H.key
                    type 'a t = 'M.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 = M.D.Varaddr.H.key
                    type 'a t = 'M.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 = M.D.Fieldinfo.H.key
                    type 'a t = 'M.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 = M.D.Compinfo.H.key
                    type 'a t = 'M.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 = M.D.Arrayinfo.H.key
                    type 'a t = 'M.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 = M.D.Logicvar.H.key
                    type 'a t = 'M.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
        type poffset =
            Ofield of Cil_types.fieldinfo
          | Oindex of Funvar_mem.Create.Lookup.D.integer * Ctypes.c_object
        type path =
            M.mem * Cil_types.varinfo *
            Funvar_mem.Create.Lookup.poffset list * Ctypes.c_object
        val get_offset :
          Formula.abstract Funvar_mem.Create.Lookup.D.F.term ->
          Funvar_mem.Create.Lookup.poffset ->
          Funvar_mem.Create.Lookup.D.abstract
        val access :
          Formula.abstract Funvar_mem.Create.Lookup.D.F.term ->
          Funvar_mem.Create.Lookup.poffset list ->
          Formula.abstract Funvar_mem.Create.Lookup.D.F.term
        val mloc_of_path :
          M.mem ->
          Cil_types.varinfo -> Funvar_mem.Create.Lookup.poffset list -> M.loc
        val pp_path :
          Format.formatter -> 'a * Cil_types.varinfo * 'b list * '-> unit
      end
    module Model :
      sig
        module F :
          sig
            type 'a term = 'M.D.F.term
            type pred = M.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 = M.D.F.var
            type pool = M.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 = M.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 A :
          sig
            module D :
              sig
                module F :
                  sig
                    type 'a term = 'M.D.F.term
                    type pred = M.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 = M.D.F.var
                    type pool = M.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 = M.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 =
                  M.D.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'M.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 = M.D.context
                type bindings = M.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 = M.D.substitution
                val apply : substitution -> 'F.term -> 'F.term
                type havoc =
                  M.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 = M.D.Varinfo.H.key
                        type 'a t = 'M.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 = M.D.Varaddr.H.key
                        type 'a t = 'M.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 = M.D.Fieldinfo.H.key
                        type 'a t = 'M.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 = M.D.Compinfo.H.key
                        type 'a t = 'M.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 = M.D.Arrayinfo.H.key
                        type 'a t = 'M.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 = M.D.Logicvar.H.key
                        type 'a t = 'M.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 = 'M.D.F.term
                    type pred = M.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 = M.D.F.var
                    type pool = M.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 = M.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 =
                  M.D.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'M.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 = M.D.context
                type bindings = M.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 = M.D.substitution
                val apply : substitution -> 'F.term -> 'F.term
                type havoc =
                  M.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 = M.D.Varinfo.H.key
                        type 'a t = 'M.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 = M.D.Varaddr.H.key
                        type 'a t = 'M.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 = M.D.Fieldinfo.H.key
                        type 'a t = 'M.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 = M.D.Compinfo.H.key
                        type 'a t = 'M.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 = M.D.Arrayinfo.H.key
                        type 'a t = 'M.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 = M.D.Logicvar.H.key
                        type 'a t = 'M.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
        module D :
          sig
            module F :
              sig
                type 'a term = 'M.D.F.term
                type pred = M.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 = M.D.F.var
                type pool = M.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 = M.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 =
              M.D.interval = {
              inf : integer option;
              sup : integer option;
            }
            type 'a assigned =
              'M.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 = M.D.context
            type bindings = M.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 = M.D.substitution
            val apply : substitution -> 'F.term -> 'F.term
            type havoc =
              M.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 = M.D.Varinfo.H.key
                    type 'a t = 'M.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 = M.D.Varaddr.H.key
                    type 'a t = 'M.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 = M.D.Fieldinfo.H.key
                    type 'a t = 'M.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 = M.D.Compinfo.H.key
                    type 'a t = 'M.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 = M.D.Arrayinfo.H.key
                    type 'a t = 'M.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 = M.D.Logicvar.H.key
                    type 'a t = 'M.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
        type loc = Path of Funvar_mem.Create.Lookup.path | Mloc of M.loc
        val loc_of_pointer :
          Ctypes.c_object -> M.D.pointer -> Funvar_mem.Create.Model.loc
        val pointer_of_loc : Funvar_mem.Create.Model.loc -> M.D.pointer
        val pp_loc : Format.formatter -> Funvar_mem.Create.Model.loc -> unit
        val cast_loc_to_int :
          Cil_types.typ ->
          Funvar_mem.Create.Model.loc -> Ctypes.c_int -> M.D.integer
        val cast_int_to_loc :
          Ctypes.c_int ->
          M.D.integer -> Cil_types.typ -> Funvar_mem.Create.Model.loc
      end
    module D :
      sig
        module F :
          sig
            type 'a term = 'Model.D.F.term
            type pred = Model.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 = Model.D.F.var
            type pool = Model.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 = Model.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 =
          Model.D.interval = {
          inf : integer option;
          sup : integer option;
        }
        type 'a assigned =
          'Model.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 = Model.D.context
        type bindings = Model.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 = Model.D.substitution
        val apply : substitution -> 'F.term -> 'F.term
        type havoc =
          Model.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 = Model.D.Varinfo.H.key
                type 'a t = 'Model.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 = Model.D.Varaddr.H.key
                type 'a t = 'Model.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 = Model.D.Fieldinfo.H.key
                type 'a t = 'Model.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 = Model.D.Compinfo.H.key
                type 'a t = 'Model.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 = Model.D.Arrayinfo.H.key
                type 'a t = 'Model.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 = Model.D.Logicvar.H.key
                type 'a t = 'Model.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 A :
      sig
        module D :
          sig
            module F :
              sig
                type 'a term = 'Model.D.F.term
                type pred = Model.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 = Model.D.F.var
                type pool = Model.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 = Model.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 =
              Model.D.interval = {
              inf : integer option;
              sup : integer option;
            }
            type 'a assigned =
              'Model.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 = Model.D.context
            type bindings = Model.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 = Model.D.substitution
            val apply : substitution -> 'F.term -> 'F.term
            type havoc =
              Model.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 = Model.D.Varinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Varaddr.H.key
                    type 'a t = 'Model.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 = Model.D.Fieldinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Compinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Arrayinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Logicvar.H.key
                    type 'a t = 'Model.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 = 'Model.D.F.term
                type pred = Model.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 = Model.D.F.var
                type pool = Model.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 = Model.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 =
              Model.D.interval = {
              inf : integer option;
              sup : integer option;
            }
            type 'a assigned =
              'Model.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 = Model.D.context
            type bindings = Model.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 = Model.D.substitution
            val apply : substitution -> 'F.term -> 'F.term
            type havoc =
              Model.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 = Model.D.Varinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Varaddr.H.key
                    type 'a t = 'Model.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 = Model.D.Fieldinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Compinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Arrayinfo.H.key
                    type 'a t = 'Model.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 = Model.D.Logicvar.H.key
                    type 'a t = 'Model.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 = Model.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 =
      Datalib.Cvalues(Model).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 env =
        (Cil_types.varinfo *
         (Funvar_mem.Create.Model.F.var * Ctypes.c_object))
        list Pervasives.ref
    type mem = { mem : M.mem; env : Funvar_mem.Create.env; }
    type fun_frame =
        (Clabels.c_label * Funvar_mem.Create.env) list Pervasives.ref
    val new_fun_frame :
      'a option ->
      'a option -> 'a option -> (Clabels.c_label * 'a) list Pervasives.ref
    val create : unit -> 'a list Pervasives.ref
    val env_at :
      ('a * 'b list Pervasives.ref) list Pervasives.ref ->
      '-> 'b list Pervasives.ref
    type frame = { mframe : M.frame; fframe : Funvar_mem.Create.fun_frame; }
    val opt_mem : Funvar_mem.Create.mem option -> M.mem option
    val opt_env :
      Funvar_mem.Create.mem option -> Funvar_mem.Create.env option
    val new_frame :
      Kernel_function.t ->
      m_here:Funvar_mem.Create.mem option ->
      m_pre:Funvar_mem.Create.mem option ->
      m_post:Funvar_mem.Create.mem option ->
      M.D.F.var option -> Funvar_mem.Create.frame
    val mem_at :
      Funvar_mem.Create.frame -> Clabels.c_label -> Funvar_mem.Create.mem
    val get_funvar :
      (Cil_datatype.Varinfo.t * (D.F.var * Ctypes.c_object)) list
      Pervasives.ref -> Cil_datatype.Varinfo.t -> D.F.var
    val cvar :
      Funvar_mem.Create.mem ->
      Cil_types.varinfo -> Funvar_mem.Create.Model.loc
    val shift :
      Funvar_mem.Create.Model.loc ->
      Ctypes.c_object -> M.D.integer -> Funvar_mem.Create.Model.loc
    val index :
      Funvar_mem.Create.Model.loc ->
      Ctypes.c_object -> M.D.integer -> Funvar_mem.Create.Model.loc
    val field :
      Funvar_mem.Create.Model.loc ->
      Cil_types.fieldinfo -> Funvar_mem.Create.Model.loc
    val startof :
      Funvar_mem.Create.Model.loc ->
      Ctypes.c_object -> Funvar_mem.Create.Model.loc
    val cast_loc_to_loc :
      Cil_types.typ ->
      Cil_types.typ ->
      Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.loc
    val fun_load :
      (Cil_datatype.Varinfo.t * (D.F.var * Ctypes.c_object)) list
      Pervasives.ref ->
      'a * Cil_datatype.Varinfo.t * Funvar_mem.Create.Lookup.poffset list *
      Ctypes.c_object -> value
    val loc_of_path :
      Funvar_mem.Create.mem ->
      'a * Cil_datatype.Varinfo.t * Funvar_mem.Create.Lookup.poffset list *
      Ctypes.c_object -> M.loc
    val array_of_path :
      (Cil_datatype.Varinfo.t * (D.F.var * Ctypes.c_object)) list
      Pervasives.ref ->
      'a * Cil_datatype.Varinfo.t * Funvar_mem.Create.Lookup.poffset list *
      Ctypes.c_object -> D.array
    val value_of_mvalue : M.value -> value
    val mvalue_of_value : value -> M.value
    val load :
      Funvar_mem.Create.mem ->
      Ctypes.c_object -> Funvar_mem.Create.Model.loc -> value
    val mloc_of_loc : Funvar_mem.Create.Model.loc -> M.loc
    val massigned :
      Funvar_mem.Create.Model.loc D.assigned -> M.loc D.assigned
    type m_dzone = M.m_dzone
    type dzone = M.dzone
    val tau_of_dzone : Formula.tau
    val dzone_assigned : Funvar_mem.Create.Model.loc D.assigned -> M.dzone
    val dzone_subset : M.dzone -> M.dzone -> M.D.F.pred
    val dzone_union : M.dzone -> M.dzone -> M.dzone
    val dzone_empty : unit -> M.dzone
    val effect_supported : bool
    module Z :
      sig
        type base
        val cvar : D.integer -> Cil_types.varinfo -> base
        val root : D.integer -> base
        val base : D.integer -> base
        type path
        val is_atomic : Ctypes.c_object -> bool
        val p_block : atomic:bool -> Ctypes.c_object -> path
        val p_field : atomic:bool -> path -> Cil_types.fieldinfo -> path
        val p_index :
          atomic:bool -> path -> Ctypes.c_object -> offset:D.integer -> path
        val p_range :
          atomic:bool ->
          path ->
          Ctypes.c_object -> offset:D.integer -> length:D.integer -> path
        val p_interval :
          atomic:bool -> path -> Ctypes.c_object -> D.interval -> path
        type region
        val pp_region : Format.formatter -> region -> unit
        val empty : region
        val union : region -> region -> region
        val block : base -> region
        val index : base -> D.integer -> region
        val range : base -> D.integer -> D.integer -> region
        val path : base -> path -> region
        val is_empty : region -> D.F.pred
        val included : region -> region -> D.F.pred
        val separated : region -> region -> D.F.pred
        val fingerprint :
          D.F.pool -> region -> D.F.var list * D.F.pred * region
        val a_sizeof : Ctypes.c_object -> D.integer
      end
    type region = Funvar_mem.Create.Z.region * M.region
    val pp_region :
      Format.formatter -> Funvar_mem.Create.Z.region * M.region -> unit
    val funvar_offset :
      atomic:bool ->
      Funvar_mem.Create.Z.base ->
      Funvar_mem.Create.Z.path ->
      Funvar_mem.Create.Lookup.poffset list ->
      (Ctypes.c_object * D.interval) option -> Funvar_mem.Create.Z.region
    val funvar_path :
      D.Xindex.t ->
      Funvar_mem.Create.Lookup.poffset list ->
      (Ctypes.c_object * D.interval) option -> Funvar_mem.Create.Z.region
    val region_assigned :
      Funvar_mem.Create.Model.loc D.assigned ->
      Funvar_mem.Create.Z.region * M.region
    val region_empty : unit -> Funvar_mem.Create.Z.region * M.region
    val region_union :
      Funvar_mem.Create.Z.region * M.region ->
      Funvar_mem.Create.Z.region * M.region ->
      Funvar_mem.Create.Z.region * M.region
    val region_included :
      Funvar_mem.Create.Z.region * M.region ->
      Funvar_mem.Create.Z.region * M.region -> Funvar_mem.Create.Model.F.pred
    val region_separated :
      Funvar_mem.Create.Z.region * M.region ->
      Funvar_mem.Create.Z.region * M.region -> Funvar_mem.Create.Model.F.pred
    val region_fingerprint :
      D.F.pool ->
      Funvar_mem.Create.Z.region * M.region ->
      D.F.var list * Funvar_mem.Create.Model.F.pred *
      (Funvar_mem.Create.Z.region * M.region)
    val region_supported : bool
    val result : Funvar_mem.Create.frame -> M.D.F.var * Cil_types.typ
    val exit_status : Funvar_mem.Create.frame -> M.D.F.var
    val get_exit_status : Funvar_mem.Create.frame -> M.D.F.var option
    val set_exit_status :
      Funvar_mem.Create.frame -> M.D.F.var -> Funvar_mem.Create.frame
    val loc_of_funloc : Funvar_mem.Create.Model.loc -> M.loc
    val base_address :
      Funvar_mem.Create.mem ->
      Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.loc
    val block_length :
      Funvar_mem.Create.mem ->
      Funvar_mem.Create.Model.loc -> Formula.integer M.D.F.term
    val valid :
      Funvar_mem.Create.mem ->
      Funvar_mem.Create.Model.loc D.assigned -> M.D.F.pred
    val separated :
      Funvar_mem.Create.Model.loc D.assigned ->
      Funvar_mem.Create.Model.loc D.assigned -> M.D.F.pred
    type fun_closure = Cil_types.varinfo * string
    type closure =
        Fclos of Funvar_mem.Create.fun_closure
      | Mclos of M.closure
    val pp_closure : Format.formatter -> Funvar_mem.Create.closure -> unit
    val collect_signature :
      string ->
      Cil_types.varinfo ->
      '->
      'a list * Funvar_mem.Create.closure list ->
      'a list * Funvar_mem.Create.closure list
    val userdef_fun_signature :
      (Clabels.c_label * (Cil_types.varinfo * ('a * 'b)) list Pervasives.ref)
      list Pervasives.ref -> 'a list * Funvar_mem.Create.closure list
    val userdef_fun_closure :
      (Cil_datatype.Varinfo.t * (D.F.var * Ctypes.c_object)) list
      Pervasives.ref ->
      Cil_datatype.Varinfo.t * '-> 'Funvar_mem.Create.Model.F.term
    val userdef_frame : unit -> Funvar_mem.Create.frame
    val userdef_signature :
      Funvar_mem.Create.frame ->
      Formula.abstract M.D.F.term list ->
      M.D.F.pred list ->
      Funvar_mem.Create.Model.F.var list * Funvar_mem.Create.closure list
    val label_at_closure : Funvar_mem.Create.closure -> string
    val userdef_closure :
      Funvar_mem.Create.mem ->
      Funvar_mem.Create.closure ->
      Formula.abstract Funvar_mem.Create.Model.F.term
    val fupdate_at_label :
      (Clabels.c_label *
       (Cil_datatype.Varinfo.t * (D.F.var * Ctypes.c_object)) list
       Pervasives.ref)
      list Pervasives.ref -> Clabels.c_label -> D.F.pred -> D.F.pred
    val update_at_label :
      Funvar_mem.Create.frame -> Clabels.c_label -> D.F.pred -> M.D.F.pred
    val close_env :
      ('a * (D.F.var * 'b)) list Pervasives.ref -> D.F.pred -> D.F.pred
    val fquantify_at_label :
      ('a * ('b * (D.F.var * 'c)) list Pervasives.ref) list Pervasives.ref ->
      '-> D.F.pred -> D.F.pred
    val quantify_at_label :
      Funvar_mem.Create.frame -> Clabels.c_label -> D.F.pred -> M.D.F.pred
    val update :
      (Formula.abstract Funvar_mem.Create.Lookup.D.F.term ->
       Formula.abstract Funvar_mem.Create.Model.F.term) ->
      Formula.abstract Funvar_mem.Create.Lookup.D.F.term ->
      Funvar_mem.Create.Lookup.poffset list -> D.abstract
    val store :
      (Clabels.c_label *
       (Cil_datatype.Varinfo.t * (D.F.var * Ctypes.c_object)) list
       Pervasives.ref)
      list Pervasives.ref ->
      'a * Cil_datatype.Varinfo.t * Funvar_mem.Create.Lookup.poffset list *
      '-> value -> D.F.pred -> D.F.pred
    val subst_lval :
      Funvar_mem.Create.frame ->
      Ctypes.c_object ->
      Funvar_mem.Create.Model.loc -> value -> D.F.pred -> D.F.pred
    val subst_result :
      Funvar_mem.Create.frame -> value option -> M.D.F.pred -> M.D.F.pred
    val subst_havoc :
      Funvar_mem.Create.frame ->
      Funvar_mem.Create.Model.loc D.assigned -> D.havoc list
    val assigns_goal :
      Funvar_mem.Create.frame ->
      Clabels.c_label ->
      Funvar_mem.Create.Model.loc D.assigned list ->
      Clabels.c_label -> M.D.F.pred
    val assigns_supported : bool
    val local_scope :
      Funvar_mem.Create.frame ->
      Cil_types.varinfo list -> Mcfg.scope -> M.D.F.pred -> M.D.F.pred
  end