sig
  module WP :
    sig
      module F :
        sig
          type fvar = Caveat_fol.fvar
          type data =
            Caveat_fol.data = private
              D1null
            | D1base of data
            | D1addr of Cil_types.varinfo * Formula.tau
            | D1var of (Cil_types.varinfo * Clabels.c_label) option * fvar
            | D1depl of data * epath
            | D1shift of data * dterm
            | D1proj of data * epath
            | D1indir of data
            | D1mu of data * epath * dterm option
            | D1muRange of data * dterm
            | D1muI of data * dterm option * dterm option
            | D1muIrange of data * dterm
          and epath =
            Caveat_fol.epath =
              Pfield of Cil_types.fieldinfo
            | Pidx of dterm
          and dterm = data Fol.d_term
          val eq_data : data -> data -> bool
          val eq_var : fvar -> fvar -> bool
          val pp_data : Format.formatter -> data -> unit
          val pp_var : Format.formatter -> fvar -> unit
          type 'a term = dterm
          type pred = dterm Fol.t_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 = fvar
          type pool = unit
          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 = Caveat_fol.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
          val ctype_of_fvar : fvar -> Cil_types.typ option
          val data_of_cvar_at_l :
            fvar Cil_datatype.Varinfo.Hashtbl.t ->
            Clabels.c_label ->
            Cil_types.varinfo -> (Cil_types.varinfo -> Formula.tau) -> data
          val fvar_of_cvar_at :
            create:bool ->
            fvar Cil_datatype.Varinfo.Hashtbl.t ->
            Clabels.c_label ->
            Cil_types.varinfo -> (Cil_types.varinfo -> Formula.tau) -> fvar
          val addr : Cil_types.varinfo -> Formula.tau -> data
          val null : data
          val base : data -> data
          val shift_field : data -> Cil_types.fieldinfo -> data
          val shift_index : data -> dterm -> data
          val shift_epath : data -> epath -> data
          val shift_pointer : data -> dterm -> data
          val proj : data -> epath -> dterm
          val indir :
            fvar Cil_datatype.Varinfo.Hashtbl.t ->
            Clabels.c_label -> data -> dterm
          val mk_mu : data -> epath -> dterm option -> data
          val mk_mu_range : data -> dterm -> data
          val mk_mu_sh_indir : data -> dterm option -> dterm option -> data
          val mk_mu_range_indir : data -> dterm -> data
          val addr_of_data : data -> data
          val term_of_var : fvar -> dterm
          val term_of_data : data -> dterm
          val data_of_term : dterm -> data
          val visit_data_in_pred :
            all:bool ->
            (('-> dterm -> 'a) -> '-> data -> 'a) -> '-> pred -> 'a
          val subst_data_in_pred : (data -> data) -> pred -> pred
        end
      module D1 :
        sig
          module F :
            sig
              type 'a term = 'F.term
              type pred = 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 = F.var
              type pool = 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 = 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 =
            Datalib.Create(F).interval = {
            inf : integer option;
            sup : integer option;
          }
          type 'a assigned =
            'Datalib.Create(F).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 = Datalib.Create(F).context
          type bindings = Datalib.Create(F).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 = Datalib.Create(F).substitution
          val apply : substitution -> 'F.term -> 'F.term
          type havoc =
            Datalib.Create(F).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 = Datalib.Create(F).Varinfo.H.key
                  type 'a t = 'Datalib.Create(F).Varinfo.H.t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key -> '-> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key -> '-> unit
                  val mem : 'a t -> key -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val length : 'a t -> int
                end
              val index : t -> H.key
              val prefix : string
              val basename : t -> string
              val location : t -> 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 = Datalib.Create(F).Varaddr.H.key
                  type 'a t = 'Datalib.Create(F).Varaddr.H.t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key -> '-> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key -> '-> unit
                  val mem : 'a t -> key -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val length : 'a t -> int
                end
              val index : t -> H.key
              val prefix : string
              val basename : t -> string
              val location : t -> 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 = Datalib.Create(F).Fieldinfo.H.key
                  type 'a t = 'Datalib.Create(F).Fieldinfo.H.t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key -> '-> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key -> '-> unit
                  val mem : 'a t -> key -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val length : 'a t -> int
                end
              val index : t -> H.key
              val prefix : string
              val basename : t -> string
              val location : t -> 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 = Datalib.Create(F).Compinfo.H.key
                  type 'a t = 'Datalib.Create(F).Compinfo.H.t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key -> '-> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key -> '-> unit
                  val mem : 'a t -> key -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val length : 'a t -> int
                end
              val index : t -> H.key
              val prefix : string
              val basename : t -> string
              val location : t -> 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 = Datalib.Create(F).Arrayinfo.H.key
                  type 'a t = 'Datalib.Create(F).Arrayinfo.H.t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key -> '-> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key -> '-> unit
                  val mem : 'a t -> key -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val length : 'a t -> int
                end
              val index : t -> H.key
              val prefix : string
              val basename : t -> string
              val location : t -> 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 = Datalib.Create(F).Logicvar.H.key
                  type 'a t = 'Datalib.Create(F).Logicvar.H.t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val copy : 'a t -> 'a t
                  val add : 'a t -> key -> '-> unit
                  val remove : 'a t -> key -> unit
                  val find : 'a t -> key -> 'a
                  val find_all : 'a t -> key -> 'a list
                  val replace : 'a t -> key -> '-> unit
                  val mem : 'a t -> key -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val length : 'a t -> int
                end
              val index : t -> H.key
              val prefix : string
              val basename : t -> string
              val location : t -> 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 Shared :
        sig
          module Hlib :
            sig
              val addr : D1.name -> D1.pointer
              val shift_pointer :
                D1.pointer -> Formula.integer D1.F.term -> D1.pointer
              val shift_field : D1.pointer -> D1.name -> D1.pointer
              val shift_ufield : D1.pointer -> D1.name -> D1.pointer
              val shift_index :
                D1.pointer -> Formula.integer D1.F.term -> D1.pointer
              val havoc_index :
                D1.array -> Formula.integer D1.F.term -> D1.array
              val havoc_field : D1.record -> D1.name -> D1.record
              val havoc_ufield : D1.urecord -> D1.name -> D1.urecord
              val base : D1.pointer -> D1.pointer
              val block_length : D1.pointer -> Formula.integer D1.F.term
              val valid_pointer : D1.pointer -> D1.F.pred
              val valid_range : D1.pointer -> D1.set -> D1.F.pred
              val separated : D1.pointer -> D1.pointer -> D1.F.pred
              val array_length : D1.pointer -> Formula.integer D1.F.term
            end
          val get_array_length :
            Cil_types.typ -> Formula.integer D1.F.term option
          val mk_v_array_length :
            D1.pointer -> Formula.integer D1.F.term -> D1.F.pred
          module Globals :
            sig
              type t = Cil_types.varinfo
              val define : t -> unit
              val get_definition : t -> D1.F.pred Formula.declaration
              val on_definition :
                (t -> D1.F.pred Formula.declaration -> unit) -> unit
            end
        end
      module CavLib :
        sig
          val indir : D1.pointer -> Ctypes.c_object -> D1.abstract
          val mu_indir :
            D1.pointer ->
            D1.integer -> Ctypes.c_object -> D1.abstract -> D1.abstract
          val mu_range_indir :
            D1.pointer -> Formula.m_set F.term -> D1.abstract
          val ptr : D1.pointer -> D1.pointer
        end
      module Model :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'F.term
                  type pred = 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 = F.var
                  type pool = 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 = 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 =
                Datalib.Create(F).interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'Datalib.Create(F).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 = Datalib.Create(F).context
              type bindings = Datalib.Create(F).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 = Datalib.Create(F).substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                Datalib.Create(F).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 = Datalib.Create(F).Varinfo.H.key
                      type 'a t = 'Datalib.Create(F).Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> 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 = Datalib.Create(F).Varaddr.H.key
                      type 'a t = 'Datalib.Create(F).Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> 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 = Datalib.Create(F).Fieldinfo.H.key
                      type 'a t = 'Datalib.Create(F).Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> 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 = Datalib.Create(F).Compinfo.H.key
                      type 'a t = 'Datalib.Create(F).Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> 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 = Datalib.Create(F).Arrayinfo.H.key
                      type 'a t = 'Datalib.Create(F).Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> 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 = Datalib.Create(F).Logicvar.H.key
                      type 'a t = 'Datalib.Create(F).Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> 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 = 'D.F.term
                      type pred = D.F.pred
                      val e_call :
                        string ->
                        Formula.abstract term list -> Formula.abstract term
                      val p_call :
                        string -> Formula.abstract term list -> pred
                      val wrap : 'a term -> Formula.abstract term
                      val unwrap : Formula.abstract term -> 'a term
                      val e_true : Formula.boolean term
                      val e_false : Formula.boolean term
                      val e_int : int -> Formula.integer term
                      val e_float : float -> Formula.real term
                      val e_icst : string -> Formula.integer term
                      val e_rcst : string -> Formula.real term
                      val e_int64 : int64 -> Formula.integer term
                      val e_ineg :
                        Formula.integer term -> Formula.integer term
                      val e_rneg : Formula.real term -> Formula.real term
                      val e_iop :
                        Formula.integer_op ->
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_rop :
                        Formula.real_op ->
                        Formula.real term ->
                        Formula.real term -> Formula.real term
                      val e_icmp :
                        Formula.cmp_op ->
                        Formula.integer term ->
                        Formula.integer term -> Formula.boolean term
                      val e_rcmp :
                        Formula.cmp_op ->
                        Formula.real term ->
                        Formula.real term -> Formula.boolean term
                      val p_icmp :
                        Formula.cmp_op ->
                        Formula.integer term -> Formula.integer term -> pred
                      val p_rcmp :
                        Formula.cmp_op ->
                        Formula.real term -> Formula.real term -> pred
                      val e_bnot :
                        Formula.integer term -> Formula.integer term
                      val e_band :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_bor :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_bxor :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_lshift :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_rshift :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val integer_of_real :
                        Formula.real term -> Formula.integer term
                      val real_of_integer :
                        Formula.integer term -> Formula.real term
                      val e_bool :
                        Formula.boolean term -> Formula.integer term
                      val e_not :
                        Formula.boolean term -> Formula.boolean term
                      val e_and :
                        Formula.boolean term ->
                        Formula.boolean term -> Formula.boolean term
                      val e_or :
                        Formula.boolean term ->
                        Formula.boolean term -> Formula.boolean term
                      val e_cond :
                        Formula.boolean term -> 'a term -> 'a term -> 'a term
                      val p_cond :
                        Formula.boolean term -> pred -> pred -> pred
                      val p_true : pred
                      val p_false : pred
                      val p_bool : Formula.boolean term -> pred
                      val p_and : pred -> pred -> pred
                      val p_or : pred -> pred -> pred
                      val p_xor : pred -> pred -> pred
                      val p_not : pred -> pred
                      val p_implies : pred -> pred -> pred
                      val p_iff : pred -> pred -> pred
                      val p_eq : 'a term -> 'a term -> pred
                      val p_neq : 'a term -> 'a term -> pred
                      val p_conj : pred list -> pred
                      val p_disj : pred list -> pred
                      val p_named : string -> pred -> pred
                      val is_true : pred -> bool
                      val is_false : pred -> bool
                      val huge_term : int -> 'a term -> bool
                      val huge_pred : int -> pred -> bool
                      type var = D.F.var
                      type pool = D.F.pool
                      val pool : unit -> pool
                      val fresh : pool -> string -> Formula.kind -> var
                      val freshen : pool -> var -> var
                      val var : var -> 'a term
                      val eq_var : var -> var -> bool
                      val name_of_var : var -> string
                      val tau_of_var : var -> Formula.tau
                      val kind_of_var : var -> Formula.kind
                      val term_has_var : var list -> 'a term -> bool
                      val pred_has_var : var list -> pred -> bool
                      val term_closed : 'a term -> bool
                      val pred_closed : pred -> bool
                      val p_forall : var list -> pred -> pred
                      val p_exists : var list -> pred -> pred
                      val p_subst :
                        (var -> var option) -> var -> 'a term -> pred -> pred
                      val e_subst :
                        (var -> var option) ->
                        var -> 'a term -> 'b term -> 'b term
                      val e_rename : (var * var) list -> 'a term -> 'a term
                      val equal_terms : 'a term -> 'a term -> bool
                      type alpha = D.F.alpha
                      val empty_alpha : alpha
                      val fold_alpha :
                        (var -> var -> '-> 'a) -> alpha -> '-> 'a
                      val p_more_alpha_cv : alpha -> pred -> alpha * pred
                      val p_alpha_cv : pred -> var list * pred
                      val pp_var : Format.formatter -> var -> unit
                      val pp_term : Format.formatter -> 'a term -> unit
                      val pp_pred : Format.formatter -> pred -> unit
                      val pp_decl :
                        Format.formatter -> pred Formula.declaration -> unit
                      val pp_goal :
                        Format.formatter -> string -> pred -> unit
                    end
                  type format = Formula.m_format F.term
                  type abstract = Formula.abstract F.term
                  type integer = Formula.integer F.term
                  type real = Formula.real F.term
                  type boolean = Formula.boolean F.term
                  type record = Formula.m_array F.term
                  type urecord = Formula.m_array F.term
                  type array = Formula.m_array F.term
                  type set = Formula.m_set F.term
                  type name = Formula.integer F.term
                  type pointer = Formula.m_pointer F.term
                  val pp_kind : Format.formatter -> Mdata.kind -> unit
                  type interval =
                    D.interval = {
                    inf : integer option;
                    sup : integer option;
                  }
                  type 'a assigned =
                    'D.assigned =
                      Aloc of Ctypes.c_object * 'a
                    | Arange of Ctypes.c_object * 'a * interval
                  val pp_interval : Format.formatter -> interval -> unit
                  val e_app0 : string -> 'F.term
                  val e_app1 : string -> 'F.term -> 'F.term
                  val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
                  val e_app3 :
                    string ->
                    'F.term -> 'F.term -> 'F.term -> 'F.term
                  val e_app4 :
                    string ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> 'F.term
                  val e_app5 :
                    string ->
                    'F.term ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> 'F.term
                  val p_app0 : string -> F.pred
                  val p_app1 : string -> 'F.term -> F.pred
                  val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                  val p_app3 :
                    string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                  val p_app4 :
                    string ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> F.pred
                  val p_app5 :
                    string ->
                    'F.term ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> F.pred
                  val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
                  type context = D.context
                  type bindings = D.bindings
                  class type hint =
                    object
                      method capture : F.var list -> unit
                      method has_var : F.var list -> bool
                      method pretty : Format.formatter -> unit
                      method subst : F.var -> Formula.abstract F.term -> unit
                    end
                  val closed : bindings
                  val close : bindings -> F.pred -> F.pred
                  val capture : hint list -> bindings -> unit
                  val push :
                    string -> F.pool -> bindings -> hint list -> context
                  val pop : string -> context -> bindings
                  val kill : string -> context -> unit
                  val flush : string -> context -> F.pred -> F.pred
                  val term_such_that :
                    Formula.tau -> ('F.term -> F.pred) -> 'F.term
                  val forall : F.var list -> F.pred -> F.pred
                  val exists : F.var list -> F.pred -> F.pred
                  val subst : F.var -> 'F.term -> F.pred -> F.pred
                  val fresh : string -> Mdata.vkind -> F.var
                  val alpha : F.var -> F.var option
                  val pool : unit -> F.pool
                  val vkind_of_var : F.var -> Mdata.vkind
                  val has_vars : F.var list -> F.pred -> bool
                  type substitution = D.substitution
                  val apply : substitution -> 'F.term -> 'F.term
                  type havoc =
                    D.havoc =
                      Fresh of F.var
                    | Update of F.var *
                        (substitution -> Formula.abstract F.term)
                  val havoc_static : havoc list -> F.pred -> F.pred
                  val havoc_inductive : havoc list -> F.pred -> F.pred
                  val clear : unit -> unit
                  val on_clear : (unit -> unit) -> unit
                  val fresh_name : string -> string -> string
                  val add_declaration : F.pred Formula.declaration -> unit
                  val iter :
                    Formula.section ->
                    (F.pred Formula.declaration -> unit) -> unit
                  val iter_all : (F.pred Formula.declaration -> unit) -> unit
                  val dummy : unit -> F.pred
                  module type Identifiable =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module type Registry =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                    end
                  module type Declarator =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                      val clear : unit -> unit
                      val section : Formula.section
                      val declare : t -> string -> F.pred Formula.item
                    end
                  module Register :
                    functor (D : Declarator->
                      sig
                        type t = D.t
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                      end
                  module Varinfo :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = D.Varinfo.H.key
                          type 'a t = 'D.Varinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Varaddr :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = D.Varaddr.H.key
                          type 'a t = 'D.Varaddr.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Fieldinfo :
                    sig
                      type t = Cil_types.fieldinfo
                      module H :
                        sig
                          type key = D.Fieldinfo.H.key
                          type 'a t = 'D.Fieldinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Compinfo :
                    sig
                      type t = Cil_types.compinfo
                      module H :
                        sig
                          type key = D.Compinfo.H.key
                          type 'a t = 'D.Compinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Arrayinfo :
                    sig
                      type t = Ctypes.arrayinfo
                      module H :
                        sig
                          type key = D.Arrayinfo.H.key
                          type 'a t = 'D.Arrayinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Logicvar :
                    sig
                      type t = Cil_types.logic_var
                      module H :
                        sig
                          type key = D.Logicvar.H.key
                          type 'a t = 'D.Logicvar.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module type Indexed =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Dindex :
                    functor (I : Identifiable->
                      sig
                        type t = I.t
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                  module Findex :
                    sig
                      type t = Cil_types.fieldinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Xindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Aindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Tindex :
                    sig
                      type t = Cil_types.compinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  val modulo : Ctypes.c_int -> integer -> integer
                  val guard : Ctypes.c_int -> integer -> F.pred
                  val i_convert :
                    Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                  val round : Ctypes.c_float -> real -> real
                  val f_guard : Ctypes.c_float -> real -> F.pred
                  val f_convert :
                    Ctypes.c_float -> Ctypes.c_float -> real -> real
                  val has_type : abstract -> Cil_types.logic_type -> F.pred
                  val get_range_index : array -> interval -> abstract
                  val set_range_index : array -> interval -> array
                  val empty : set
                  val singleton : abstract -> set
                  val union : set -> set -> set
                  val unions : set list -> set
                  val inter : set -> set -> set
                  val remove : set -> set -> set
                  val set_of_list : abstract list -> set
                  val add_set : set -> set -> set
                  val mult_set : set -> set -> set
                  val neg_set : set -> set
                  val interval : interval -> set
                  val equal_pointer_bool : pointer -> pointer -> boolean
                  val lt_pointer_bool : pointer -> pointer -> boolean
                  val le_pointer_bool : pointer -> pointer -> boolean
                  val lt_pointer : pointer -> pointer -> F.pred
                  val le_pointer : pointer -> pointer -> F.pred
                  val minus_pointer : pointer -> pointer -> integer
                  val is_null : pointer -> boolean
                  val null : pointer
                  val tau_of_object : Ctypes.c_object -> Formula.tau
                  val tau_of_ctype : Cil_types.typ -> Formula.tau
                  val int_format : format
                  val real_format : format
                  val pointer_format : format
                  val record_format : format
                  val urecord_format : format
                  val array_format : format -> format
                  val format_of_object : Ctypes.c_object -> format
                  val decode : format -> abstract -> 'F.term
                  val encode : format -> 'F.term -> abstract
                  val acc_field : record -> Cil_types.fieldinfo -> abstract
                  val upd_field :
                    record -> Cil_types.fieldinfo -> abstract -> record
                  val acc_index : array -> integer -> abstract
                  val upd_index : array -> integer -> abstract -> array
                  val equal :
                    Ctypes.c_object -> abstract -> abstract -> F.pred
                  val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
                  val eq_record :
                    Cil_types.compinfo -> record -> record -> F.pred
                end
              val i_neg : Ctypes.c_int -> D.integer -> D.integer
              val i_op :
                Ctypes.c_int ->
                Formula.integer_op -> D.integer -> D.integer -> D.integer
              val i_cmp :
                Ctypes.c_int ->
                Formula.cmp_op -> D.integer -> D.integer -> D.boolean
              val bits_not : Ctypes.c_int -> D.integer -> D.integer
              val bits_and :
                Ctypes.c_int -> D.integer -> D.integer -> D.integer
              val bits_or :
                Ctypes.c_int -> D.integer -> D.integer -> D.integer
              val bits_xor :
                Ctypes.c_int -> D.integer -> D.integer -> D.integer
              val bits_lshift :
                Ctypes.c_int -> D.integer -> D.integer -> D.integer
              val bits_rshift :
                Ctypes.c_int -> D.integer -> D.integer -> D.integer
            end
          module R :
            sig
              module D :
                sig
                  module F :
                    sig
                      type 'a term = 'D.F.term
                      type pred = D.F.pred
                      val e_call :
                        string ->
                        Formula.abstract term list -> Formula.abstract term
                      val p_call :
                        string -> Formula.abstract term list -> pred
                      val wrap : 'a term -> Formula.abstract term
                      val unwrap : Formula.abstract term -> 'a term
                      val e_true : Formula.boolean term
                      val e_false : Formula.boolean term
                      val e_int : int -> Formula.integer term
                      val e_float : float -> Formula.real term
                      val e_icst : string -> Formula.integer term
                      val e_rcst : string -> Formula.real term
                      val e_int64 : int64 -> Formula.integer term
                      val e_ineg :
                        Formula.integer term -> Formula.integer term
                      val e_rneg : Formula.real term -> Formula.real term
                      val e_iop :
                        Formula.integer_op ->
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_rop :
                        Formula.real_op ->
                        Formula.real term ->
                        Formula.real term -> Formula.real term
                      val e_icmp :
                        Formula.cmp_op ->
                        Formula.integer term ->
                        Formula.integer term -> Formula.boolean term
                      val e_rcmp :
                        Formula.cmp_op ->
                        Formula.real term ->
                        Formula.real term -> Formula.boolean term
                      val p_icmp :
                        Formula.cmp_op ->
                        Formula.integer term -> Formula.integer term -> pred
                      val p_rcmp :
                        Formula.cmp_op ->
                        Formula.real term -> Formula.real term -> pred
                      val e_bnot :
                        Formula.integer term -> Formula.integer term
                      val e_band :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_bor :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_bxor :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_lshift :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val e_rshift :
                        Formula.integer term ->
                        Formula.integer term -> Formula.integer term
                      val integer_of_real :
                        Formula.real term -> Formula.integer term
                      val real_of_integer :
                        Formula.integer term -> Formula.real term
                      val e_bool :
                        Formula.boolean term -> Formula.integer term
                      val e_not :
                        Formula.boolean term -> Formula.boolean term
                      val e_and :
                        Formula.boolean term ->
                        Formula.boolean term -> Formula.boolean term
                      val e_or :
                        Formula.boolean term ->
                        Formula.boolean term -> Formula.boolean term
                      val e_cond :
                        Formula.boolean term -> 'a term -> 'a term -> 'a term
                      val p_cond :
                        Formula.boolean term -> pred -> pred -> pred
                      val p_true : pred
                      val p_false : pred
                      val p_bool : Formula.boolean term -> pred
                      val p_and : pred -> pred -> pred
                      val p_or : pred -> pred -> pred
                      val p_xor : pred -> pred -> pred
                      val p_not : pred -> pred
                      val p_implies : pred -> pred -> pred
                      val p_iff : pred -> pred -> pred
                      val p_eq : 'a term -> 'a term -> pred
                      val p_neq : 'a term -> 'a term -> pred
                      val p_conj : pred list -> pred
                      val p_disj : pred list -> pred
                      val p_named : string -> pred -> pred
                      val is_true : pred -> bool
                      val is_false : pred -> bool
                      val huge_term : int -> 'a term -> bool
                      val huge_pred : int -> pred -> bool
                      type var = D.F.var
                      type pool = D.F.pool
                      val pool : unit -> pool
                      val fresh : pool -> string -> Formula.kind -> var
                      val freshen : pool -> var -> var
                      val var : var -> 'a term
                      val eq_var : var -> var -> bool
                      val name_of_var : var -> string
                      val tau_of_var : var -> Formula.tau
                      val kind_of_var : var -> Formula.kind
                      val term_has_var : var list -> 'a term -> bool
                      val pred_has_var : var list -> pred -> bool
                      val term_closed : 'a term -> bool
                      val pred_closed : pred -> bool
                      val p_forall : var list -> pred -> pred
                      val p_exists : var list -> pred -> pred
                      val p_subst :
                        (var -> var option) -> var -> 'a term -> pred -> pred
                      val e_subst :
                        (var -> var option) ->
                        var -> 'a term -> 'b term -> 'b term
                      val e_rename : (var * var) list -> 'a term -> 'a term
                      val equal_terms : 'a term -> 'a term -> bool
                      type alpha = D.F.alpha
                      val empty_alpha : alpha
                      val fold_alpha :
                        (var -> var -> '-> 'a) -> alpha -> '-> 'a
                      val p_more_alpha_cv : alpha -> pred -> alpha * pred
                      val p_alpha_cv : pred -> var list * pred
                      val pp_var : Format.formatter -> var -> unit
                      val pp_term : Format.formatter -> 'a term -> unit
                      val pp_pred : Format.formatter -> pred -> unit
                      val pp_decl :
                        Format.formatter -> pred Formula.declaration -> unit
                      val pp_goal :
                        Format.formatter -> string -> pred -> unit
                    end
                  type format = Formula.m_format F.term
                  type abstract = Formula.abstract F.term
                  type integer = Formula.integer F.term
                  type real = Formula.real F.term
                  type boolean = Formula.boolean F.term
                  type record = Formula.m_array F.term
                  type urecord = Formula.m_array F.term
                  type array = Formula.m_array F.term
                  type set = Formula.m_set F.term
                  type name = Formula.integer F.term
                  type pointer = Formula.m_pointer F.term
                  val pp_kind : Format.formatter -> Mdata.kind -> unit
                  type interval =
                    D.interval = {
                    inf : integer option;
                    sup : integer option;
                  }
                  type 'a assigned =
                    'D.assigned =
                      Aloc of Ctypes.c_object * 'a
                    | Arange of Ctypes.c_object * 'a * interval
                  val pp_interval : Format.formatter -> interval -> unit
                  val e_app0 : string -> 'F.term
                  val e_app1 : string -> 'F.term -> 'F.term
                  val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
                  val e_app3 :
                    string ->
                    'F.term -> 'F.term -> 'F.term -> 'F.term
                  val e_app4 :
                    string ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> 'F.term
                  val e_app5 :
                    string ->
                    'F.term ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> 'F.term
                  val p_app0 : string -> F.pred
                  val p_app1 : string -> 'F.term -> F.pred
                  val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                  val p_app3 :
                    string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                  val p_app4 :
                    string ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> F.pred
                  val p_app5 :
                    string ->
                    'F.term ->
                    'F.term ->
                    'F.term -> 'F.term -> 'F.term -> F.pred
                  val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
                  type context = D.context
                  type bindings = D.bindings
                  class type hint =
                    object
                      method capture : F.var list -> unit
                      method has_var : F.var list -> bool
                      method pretty : Format.formatter -> unit
                      method subst : F.var -> Formula.abstract F.term -> unit
                    end
                  val closed : bindings
                  val close : bindings -> F.pred -> F.pred
                  val capture : hint list -> bindings -> unit
                  val push :
                    string -> F.pool -> bindings -> hint list -> context
                  val pop : string -> context -> bindings
                  val kill : string -> context -> unit
                  val flush : string -> context -> F.pred -> F.pred
                  val term_such_that :
                    Formula.tau -> ('F.term -> F.pred) -> 'F.term
                  val forall : F.var list -> F.pred -> F.pred
                  val exists : F.var list -> F.pred -> F.pred
                  val subst : F.var -> 'F.term -> F.pred -> F.pred
                  val fresh : string -> Mdata.vkind -> F.var
                  val alpha : F.var -> F.var option
                  val pool : unit -> F.pool
                  val vkind_of_var : F.var -> Mdata.vkind
                  val has_vars : F.var list -> F.pred -> bool
                  type substitution = D.substitution
                  val apply : substitution -> 'F.term -> 'F.term
                  type havoc =
                    D.havoc =
                      Fresh of F.var
                    | Update of F.var *
                        (substitution -> Formula.abstract F.term)
                  val havoc_static : havoc list -> F.pred -> F.pred
                  val havoc_inductive : havoc list -> F.pred -> F.pred
                  val clear : unit -> unit
                  val on_clear : (unit -> unit) -> unit
                  val fresh_name : string -> string -> string
                  val add_declaration : F.pred Formula.declaration -> unit
                  val iter :
                    Formula.section ->
                    (F.pred Formula.declaration -> unit) -> unit
                  val iter_all : (F.pred Formula.declaration -> unit) -> unit
                  val dummy : unit -> F.pred
                  module type Identifiable =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module type Registry =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                    end
                  module type Declarator =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                      val clear : unit -> unit
                      val section : Formula.section
                      val declare : t -> string -> F.pred Formula.item
                    end
                  module Register :
                    functor (D : Declarator->
                      sig
                        type t = D.t
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                      end
                  module Varinfo :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = D.Varinfo.H.key
                          type 'a t = 'D.Varinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Varaddr :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = D.Varaddr.H.key
                          type 'a t = 'D.Varaddr.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Fieldinfo :
                    sig
                      type t = Cil_types.fieldinfo
                      module H :
                        sig
                          type key = D.Fieldinfo.H.key
                          type 'a t = 'D.Fieldinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Compinfo :
                    sig
                      type t = Cil_types.compinfo
                      module H :
                        sig
                          type key = D.Compinfo.H.key
                          type 'a t = 'D.Compinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Arrayinfo :
                    sig
                      type t = Ctypes.arrayinfo
                      module H :
                        sig
                          type key = D.Arrayinfo.H.key
                          type 'a t = 'D.Arrayinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Logicvar :
                    sig
                      type t = Cil_types.logic_var
                      module H :
                        sig
                          type key = D.Logicvar.H.key
                          type 'a t = 'D.Logicvar.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Log.source option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module type Indexed =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Dindex :
                    functor (I : Identifiable->
                      sig
                        type t = I.t
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                  module Findex :
                    sig
                      type t = Cil_types.fieldinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Xindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Aindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  module Tindex :
                    sig
                      type t = Cil_types.compinfo
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                  val modulo : Ctypes.c_int -> integer -> integer
                  val guard : Ctypes.c_int -> integer -> F.pred
                  val i_convert :
                    Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                  val round : Ctypes.c_float -> real -> real
                  val f_guard : Ctypes.c_float -> real -> F.pred
                  val f_convert :
                    Ctypes.c_float -> Ctypes.c_float -> real -> real
                  val has_type : abstract -> Cil_types.logic_type -> F.pred
                  val get_range_index : array -> interval -> abstract
                  val set_range_index : array -> interval -> array
                  val empty : set
                  val singleton : abstract -> set
                  val union : set -> set -> set
                  val unions : set list -> set
                  val inter : set -> set -> set
                  val remove : set -> set -> set
                  val set_of_list : abstract list -> set
                  val add_set : set -> set -> set
                  val mult_set : set -> set -> set
                  val neg_set : set -> set
                  val interval : interval -> set
                  val equal_pointer_bool : pointer -> pointer -> boolean
                  val lt_pointer_bool : pointer -> pointer -> boolean
                  val le_pointer_bool : pointer -> pointer -> boolean
                  val lt_pointer : pointer -> pointer -> F.pred
                  val le_pointer : pointer -> pointer -> F.pred
                  val minus_pointer : pointer -> pointer -> integer
                  val is_null : pointer -> boolean
                  val null : pointer
                  val tau_of_object : Ctypes.c_object -> Formula.tau
                  val tau_of_ctype : Cil_types.typ -> Formula.tau
                  val int_format : format
                  val real_format : format
                  val pointer_format : format
                  val record_format : format
                  val urecord_format : format
                  val array_format : format -> format
                  val format_of_object : Ctypes.c_object -> format
                  val decode : format -> abstract -> 'F.term
                  val encode : format -> 'F.term -> abstract
                  val acc_field : record -> Cil_types.fieldinfo -> abstract
                  val upd_field :
                    record -> Cil_types.fieldinfo -> abstract -> record
                  val acc_index : array -> integer -> abstract
                  val upd_index : array -> integer -> abstract -> array
                  val equal :
                    Ctypes.c_object -> abstract -> abstract -> F.pred
                  val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
                  val eq_record :
                    Cil_types.compinfo -> record -> record -> F.pred
                end
              val f_neg : Ctypes.c_float -> D.real -> D.real
              val f_op :
                Ctypes.c_float ->
                Formula.real_op -> D.real -> D.real -> D.real
              val f_cmp :
                Ctypes.c_float ->
                Formula.cmp_op -> D.real -> D.real -> D.boolean
            end
          type loc = F.data
          val pp_loc : Format.formatter -> F.data -> unit
          val pointer_of_loc : F.data -> F.dterm
          val loc_of_pointer : '-> F.dterm -> F.data
          val cast_loc_to_int : '-> '-> '-> 'd
          val cast_int_to_loc : '-> '-> '-> 'd
        end
      val top_loc_term : F.data -> D1.pointer
      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 mem = {
        label : Clabels.c_label;
        variables : F.var Cil_datatype.Varinfo.Hashtbl.t;
      }
      type frame = {
        kf : Kernel_function.t;
        mutable states : (Clabels.c_label * mem) list;
        mutable result : F.var option;
        mutable exit_status : F.var option;
        return : Cil_types.typ option;
      }
      val global_frame : unit -> frame
      val new_frame :
        Kernel_function.t ->
        m_here:mem option ->
        m_pre:mem option -> m_post:mem option -> F.var option -> frame
      val mem_at : frame -> Clabels.c_label -> mem
      val result : frame -> F.var * Cil_types.typ
      val exit_status : frame -> F.var
      val set_exit_status : frame -> F.var -> frame
      val get_exit_status : frame -> F.var option
      val get_var : mem -> Cil_types.varinfo -> F.fvar
      val null : F.data
      val base_address : '-> F.data -> F.data
      val cvar : '-> Shared.Globals.t -> F.data
      val field : F.data -> Cil_types.fieldinfo -> F.data
      val index : F.data -> '-> F.dterm -> F.data
      val shift : F.data -> '-> F.dterm -> F.data
      val startof : F.data -> '-> F.data
      val var_data : mem -> Cil_types.varinfo -> F.data
      val var_data_term : mem -> Cil_types.varinfo -> F.dterm
      val indir : mem -> F.data -> F.dterm
      val check_indir_label : Clabels.c_label -> F.data -> unit
      val load : mem -> Ctypes.c_object -> F.data -> value
      val block_length : '-> F.data -> Formula.integer D1.F.term
      val disj : F.data -> F.data -> D1.F.pred
      val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> '-> 'b
      val direct_lval : F.data -> bool
      val logic_data : F.data -> bool
      val add_unique : ('-> '-> bool) -> '-> 'a list -> 'a list
      val get_read_addr : bool -> F.pred -> F.data list
      val prepare_guard : F.data -> F.pred -> F.pred
      val mk_mu :
        mem ->
        F.data ->
        Cil_types.varinfo * (F.data -> F.data) *
        (F.data -> F.dterm option -> F.dterm option)
      val get_var_and_mu : mem -> loc -> 'F.term -> F.fvar * F.dterm option
      val subst : frame -> loc -> 'F.term -> D.F.pred -> D.F.pred
      val subst_lval : frame -> '-> loc -> value -> D.F.pred -> F.pred
      val subst_result : frame -> value option -> D.F.pred -> D.F.pred
      val update_at_label : frame -> Clabels.c_label -> F.pred -> F.pred
      val create_data_name : F.data -> unit
      val quantify_at_label : frame -> Clabels.c_label -> F.pred -> D.F.pred
      val local_scope : '-> '-> Mcfg.scope -> '-> 'c
      val valid : '-> F.data D.assigned -> D1.F.pred
      val separated : F.data D.assigned -> F.data D.assigned -> D1.F.pred
      type m_dzone
      type dzone = m_dzone F.term
      val tau_of_dzone : Formula.tau
      val dzone_assigned : '-> 'b
      val dzone_subset : '-> '-> 'c
      val dzone_union : '-> '-> 'c
      val dzone_empty : unit -> 'a
      val dzone_of_var : '-> '-> 'c
      val effect_supported : bool
      type region
      val pp_region : '-> '-> unit
      val region_assigned : '-> 'b
      val region_empty : '-> 'b
      val region_union : '-> '-> 'c
      val region_included : '-> '-> 'c
      val region_separated : '-> '-> 'c
      val region_fingerprint : '-> '-> 'c
      val region_supported : bool
      val ctype_of_data : F.data -> Cil_types.typ
      val subst_havoc : frame -> F.data D.assigned -> D.havoc list
      val assigns_goal : '-> '-> '-> 'd
      val assigns_supported : bool
      type closure = Cil_types.varinfo * string
      val pp_closure : Format.formatter -> Cil_types.varinfo * string -> unit
      val userdef_frame : '-> frame
      val userdef_signature :
        frame ->
        '->
        '-> F.var list * (Cil_datatype.Varinfo.Hashtbl.key * string) list
      val userdef_closure : mem -> Cil_types.varinfo * '-> F.dterm
      val label_at_closure : 'a * '-> 'b
    end
  module Export :
    sig
      val c_object_of_data : indir:bool -> WP.F.data -> Ctypes.c_object
      val fterm_of_addr : WP.D.Aindex.t -> WP.D1.pointer
      val fterm_of_field : WP.D.Findex.t -> WP.D.integer
      val fterm_of_field_access :
        WP.D.record -> Cil_types.fieldinfo -> WP.D.abstract
      val fterm_of_mu_field :
        WP.D.record -> Cil_types.fieldinfo -> WP.D.abstract -> WP.D.record
      val fterm_of_havoc_index :
        WP.D1.array -> Formula.integer WP.D1.F.term -> WP.D1.array
      val fterm_of_havoc_field :
        WP.D1.record -> WP.D.Findex.t -> WP.D1.record
      val fterm_of_mu_index :
        WP.D.array -> WP.D.integer -> WP.D.abstract -> WP.D.array
      val fterm_of_havoc_range :
        'WP.D.F.term -> 'WP.D.F.term -> 'WP.D.F.term
      val fterm_of_shift_field :
        WP.D1.pointer -> WP.D.Findex.t -> WP.D1.pointer
      val fterm_of_shift_index :
        WP.D1.pointer -> Formula.integer WP.D1.F.term -> WP.D1.pointer
      val fterm_of_shift_pointer :
        WP.D1.pointer -> Formula.integer WP.D1.F.term -> WP.D1.pointer
      val t_of_l : WP.F.data -> WP.D1.pointer
      val fterm_of_term : WP.F.dterm -> WP.F.dterm
      val uterm_of_data : WP.F.data -> unit Fol.d_term
      val fpred_of_pred : WP.F.pred -> unit Fol.d_pred
      val fdecl_of_decl :
        WP.F.pred Formula.declaration -> unit Fol.d_pred Formula.declaration
      module Create :
        functor
          (E : sig
                 type pred = unit Fol.d_pred
                 val export_goal : Format.formatter -> string -> pred -> unit
                 val export_decl :
                   Format.formatter -> pred Formula.declaration -> unit
               end->
          sig
            type pred = WP.F.pred
            val export_decl :
              Format.formatter -> WP.F.pred Formula.declaration -> unit
            val export_goal : Format.formatter -> string -> WP.F.pred -> unit
          end
    end
  module Coq :
    sig
      type pred = WP.F.pred
      val export_decl :
        Format.formatter -> WP.F.pred Formula.declaration -> unit
      val export_goal : Format.formatter -> string -> WP.F.pred -> unit
    end
  module Why :
    sig
      type pred = WP.F.pred
      val export_decl :
        Format.formatter -> WP.F.pred Formula.declaration -> unit
      val export_goal : Format.formatter -> string -> WP.F.pred -> unit
    end
  module Ergo91 :
    sig
      type pred = WP.F.pred
      val export_decl :
        Format.formatter -> WP.F.pred Formula.declaration -> unit
      val export_goal : Format.formatter -> string -> WP.F.pred -> unit
    end
  module Ergo92 :
    sig
      type pred = WP.F.pred
      val export_decl :
        Format.formatter -> WP.F.pred Formula.declaration -> unit
      val export_goal : Format.formatter -> string -> WP.F.pred -> unit
    end
  module Splitter :
    sig type pred = WP.F.pred val split : '-> '-> 'Bag.t end
end