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 :
        Caveat_mem.Make.WP.D1.pointer ->
        Ctypes.c_object -> Caveat_mem.Make.WP.D1.abstract
      val mu_indir :
        Caveat_mem.Make.WP.D1.pointer ->
        Caveat_mem.Make.WP.D1.integer ->
        Ctypes.c_object ->
        Caveat_mem.Make.WP.D1.abstract -> Caveat_mem.Make.WP.D1.abstract
      val mu_range_indir :
        Caveat_mem.Make.WP.D1.pointer ->
        Formula.m_set Caveat_mem.Make.WP.F.term ->
        Caveat_mem.Make.WP.D1.abstract
      val ptr :
        Caveat_mem.Make.WP.D1.pointer -> Caveat_mem.Make.WP.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 = Caveat_mem.Make.WP.F.data
      val pp_loc : Format.formatter -> Caveat_mem.Make.WP.F.data -> unit
      val pointer_of_loc :
        Caveat_mem.Make.WP.F.data -> Caveat_mem.Make.WP.F.dterm
      val loc_of_pointer :
        '-> Caveat_mem.Make.WP.F.dterm -> Caveat_mem.Make.WP.F.data
      val cast_loc_to_int : '-> '-> '-> 'd
      val cast_int_to_loc : '-> '-> '-> 'd
    end
  val top_loc_term :
    Caveat_mem.Make.WP.F.data -> Caveat_mem.Make.WP.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 : Caveat_mem.Make.WP.F.var Cil_datatype.Varinfo.Hashtbl.t;
  }
  type frame = {
    kf : Kernel_function.t;
    mutable states : (Clabels.c_label * Caveat_mem.Make.WP.mem) list;
    mutable result : Caveat_mem.Make.WP.F.var option;
    mutable exit_status : Caveat_mem.Make.WP.F.var option;
    return : Cil_types.typ option;
  }
  val global_frame : unit -> Caveat_mem.Make.WP.frame
  val new_frame :
    Kernel_function.t ->
    m_here:Caveat_mem.Make.WP.mem option ->
    m_pre:Caveat_mem.Make.WP.mem option ->
    m_post:Caveat_mem.Make.WP.mem option ->
    Caveat_mem.Make.WP.F.var option -> Caveat_mem.Make.WP.frame
  val mem_at :
    Caveat_mem.Make.WP.frame -> Clabels.c_label -> Caveat_mem.Make.WP.mem
  val result :
    Caveat_mem.Make.WP.frame -> Caveat_mem.Make.WP.F.var * Cil_types.typ
  val exit_status : Caveat_mem.Make.WP.frame -> Caveat_mem.Make.WP.F.var
  val set_exit_status :
    Caveat_mem.Make.WP.frame ->
    Caveat_mem.Make.WP.F.var -> Caveat_mem.Make.WP.frame
  val get_exit_status :
    Caveat_mem.Make.WP.frame -> Caveat_mem.Make.WP.F.var option
  val get_var :
    Caveat_mem.Make.WP.mem -> Cil_types.varinfo -> Caveat_mem.Make.WP.F.fvar
  val null : Caveat_mem.Make.WP.F.data
  val base_address :
    '-> Caveat_mem.Make.WP.F.data -> Caveat_mem.Make.WP.F.data
  val cvar :
    '-> Caveat_mem.Make.WP.Shared.Globals.t -> Caveat_mem.Make.WP.F.data
  val field :
    Caveat_mem.Make.WP.F.data ->
    Cil_types.fieldinfo -> Caveat_mem.Make.WP.F.data
  val index :
    Caveat_mem.Make.WP.F.data ->
    '-> Caveat_mem.Make.WP.F.dterm -> Caveat_mem.Make.WP.F.data
  val shift :
    Caveat_mem.Make.WP.F.data ->
    '-> Caveat_mem.Make.WP.F.dterm -> Caveat_mem.Make.WP.F.data
  val startof : Caveat_mem.Make.WP.F.data -> '-> Caveat_mem.Make.WP.F.data
  val var_data :
    Caveat_mem.Make.WP.mem -> Cil_types.varinfo -> Caveat_mem.Make.WP.F.data
  val var_data_term :
    Caveat_mem.Make.WP.mem -> Cil_types.varinfo -> Caveat_mem.Make.WP.F.dterm
  val indir :
    Caveat_mem.Make.WP.mem ->
    Caveat_mem.Make.WP.F.data -> Caveat_mem.Make.WP.F.dterm
  val check_indir_label :
    Clabels.c_label -> Caveat_mem.Make.WP.F.data -> unit
  val load :
    Caveat_mem.Make.WP.mem ->
    Ctypes.c_object -> Caveat_mem.Make.WP.F.data -> value
  val block_length :
    '->
    Caveat_mem.Make.WP.F.data -> Formula.integer Caveat_mem.Make.WP.D1.F.term
  val disj :
    Caveat_mem.Make.WP.F.data ->
    Caveat_mem.Make.WP.F.data -> Caveat_mem.Make.WP.D1.F.pred
  val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> '-> 'b
  val direct_lval : Caveat_mem.Make.WP.F.data -> bool
  val logic_data : Caveat_mem.Make.WP.F.data -> bool
  val add_unique : ('-> '-> bool) -> '-> 'a list -> 'a list
  val get_read_addr :
    bool -> Caveat_mem.Make.WP.F.pred -> Caveat_mem.Make.WP.F.data list
  val prepare_guard :
    Caveat_mem.Make.WP.F.data ->
    Caveat_mem.Make.WP.F.pred -> Caveat_mem.Make.WP.F.pred
  val mk_mu :
    Caveat_mem.Make.WP.mem ->
    Caveat_mem.Make.WP.F.data ->
    Cil_types.varinfo *
    (Caveat_mem.Make.WP.F.data -> Caveat_mem.Make.WP.F.data) *
    (Caveat_mem.Make.WP.F.data ->
     Caveat_mem.Make.WP.F.dterm option -> Caveat_mem.Make.WP.F.dterm option)
  val get_var_and_mu :
    Caveat_mem.Make.WP.mem ->
    loc ->
    'Caveat_mem.Make.WP.F.term ->
    Caveat_mem.Make.WP.F.fvar * Caveat_mem.Make.WP.F.dterm option
  val subst :
    Caveat_mem.Make.WP.frame ->
    loc -> 'Caveat_mem.Make.WP.F.term -> D.F.pred -> D.F.pred
  val subst_lval :
    Caveat_mem.Make.WP.frame ->
    '-> loc -> value -> D.F.pred -> Caveat_mem.Make.WP.F.pred
  val subst_result :
    Caveat_mem.Make.WP.frame -> value option -> D.F.pred -> D.F.pred
  val update_at_label :
    Caveat_mem.Make.WP.frame ->
    Clabels.c_label -> Caveat_mem.Make.WP.F.pred -> Caveat_mem.Make.WP.F.pred
  val create_data_name : Caveat_mem.Make.WP.F.data -> unit
  val quantify_at_label :
    Caveat_mem.Make.WP.frame ->
    Clabels.c_label -> Caveat_mem.Make.WP.F.pred -> D.F.pred
  val local_scope : '-> '-> Mcfg.scope -> '-> 'c
  val valid :
    '->
    Caveat_mem.Make.WP.F.data D.assigned -> Caveat_mem.Make.WP.D1.F.pred
  val separated :
    Caveat_mem.Make.WP.F.data D.assigned ->
    Caveat_mem.Make.WP.F.data D.assigned -> Caveat_mem.Make.WP.D1.F.pred
  type m_dzone
  type dzone = Caveat_mem.Make.WP.m_dzone Caveat_mem.Make.WP.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 : Caveat_mem.Make.WP.F.data -> Cil_types.typ
  val subst_havoc :
    Caveat_mem.Make.WP.frame ->
    Caveat_mem.Make.WP.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 : '-> Caveat_mem.Make.WP.frame
  val userdef_signature :
    Caveat_mem.Make.WP.frame ->
    '->
    '->
    Caveat_mem.Make.WP.F.var list *
    (Cil_datatype.Varinfo.Hashtbl.key * string) list
  val userdef_closure :
    Caveat_mem.Make.WP.mem ->
    Cil_types.varinfo * '-> Caveat_mem.Make.WP.F.dterm
  val label_at_closure : 'a * '-> 'b
end