sig
  module type Model =
    sig
      module D : Mdata.S
      module A :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val i_neg : Ctypes.c_int -> D.integer -> D.integer
          val i_op :
            Ctypes.c_int ->
            Formula.integer_op -> D.integer -> D.integer -> D.integer
          val i_cmp :
            Ctypes.c_int ->
            Formula.cmp_op -> D.integer -> D.integer -> D.boolean
          val bits_not : Ctypes.c_int -> D.integer -> D.integer
          val bits_and : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_xor : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_lshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_rshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
        end
      module R :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val f_neg : Ctypes.c_float -> D.real -> D.real
          val f_op :
            Ctypes.c_float -> Formula.real_op -> D.real -> D.real -> D.real
          val f_cmp :
            Ctypes.c_float -> Formula.cmp_op -> D.real -> D.real -> D.boolean
        end
      type loc
      val loc_of_pointer : Ctypes.c_object -> D.pointer -> Mvalues.Model.loc
      val pointer_of_loc : Mvalues.Model.loc -> D.pointer
      val cast_loc_to_int :
        Cil_types.typ -> Mvalues.Model.loc -> Ctypes.c_int -> D.integer
      val cast_int_to_loc :
        Ctypes.c_int -> D.integer -> Cil_types.typ -> Mvalues.Model.loc
      val pp_loc : Format.formatter -> Mvalues.Model.loc -> unit
    end
  module type Values =
    sig
      module D : Mdata.S
      module A :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val i_neg : Ctypes.c_int -> D.integer -> D.integer
          val i_op :
            Ctypes.c_int ->
            Formula.integer_op -> D.integer -> D.integer -> D.integer
          val i_cmp :
            Ctypes.c_int ->
            Formula.cmp_op -> D.integer -> D.integer -> D.boolean
          val bits_not : Ctypes.c_int -> D.integer -> D.integer
          val bits_and : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_xor : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_lshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_rshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
        end
      module R :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val f_neg : Ctypes.c_float -> D.real -> D.real
          val f_op :
            Ctypes.c_float -> Formula.real_op -> D.real -> D.real -> D.real
          val f_cmp :
            Ctypes.c_float -> Formula.cmp_op -> D.real -> D.real -> D.boolean
        end
      type loc
      val loc_of_pointer : Ctypes.c_object -> D.pointer -> loc
      val pointer_of_loc : loc -> D.pointer
      val cast_loc_to_int : Cil_types.typ -> loc -> Ctypes.c_int -> D.integer
      val cast_int_to_loc : Ctypes.c_int -> D.integer -> Cil_types.typ -> loc
      val pp_loc : Format.formatter -> loc -> unit
      type value =
          V_int of Ctypes.c_int * D.integer
        | V_float of Ctypes.c_float * D.real
        | V_pointer of Cil_types.typ * loc
        | V_record of Cil_types.compinfo * D.record
        | V_union of Cil_types.compinfo * D.urecord
        | V_array of Ctypes.arrayinfo * D.array
      val pp_value : Format.formatter -> Mvalues.Values.value -> unit
      val logic_of_value : Mvalues.Values.value -> D.abstract
      val value_of_logic :
        Ctypes.c_object -> D.abstract -> Mvalues.Values.value
    end
  module type Data =
    sig
      module D : Mdata.S
      module A :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val i_neg : Ctypes.c_int -> D.integer -> D.integer
          val i_op :
            Ctypes.c_int ->
            Formula.integer_op -> D.integer -> D.integer -> D.integer
          val i_cmp :
            Ctypes.c_int ->
            Formula.cmp_op -> D.integer -> D.integer -> D.boolean
          val bits_not : Ctypes.c_int -> D.integer -> D.integer
          val bits_and : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_xor : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_lshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_rshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
        end
      module R :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val f_neg : Ctypes.c_float -> D.real -> D.real
          val f_op :
            Ctypes.c_float -> Formula.real_op -> D.real -> D.real -> D.real
          val f_cmp :
            Ctypes.c_float -> Formula.cmp_op -> D.real -> D.real -> D.boolean
        end
      type loc
      val loc_of_pointer : Ctypes.c_object -> D.pointer -> loc
      val pointer_of_loc : loc -> D.pointer
      val cast_loc_to_int : Cil_types.typ -> loc -> Ctypes.c_int -> D.integer
      val cast_int_to_loc : Ctypes.c_int -> D.integer -> Cil_types.typ -> loc
      val pp_loc : Format.formatter -> loc -> unit
      type value =
          V_int of Ctypes.c_int * D.integer
        | V_float of Ctypes.c_float * D.real
        | V_pointer of Cil_types.typ * loc
        | V_record of Cil_types.compinfo * D.record
        | V_union of Cil_types.compinfo * D.urecord
        | V_array of Ctypes.arrayinfo * D.array
      val pp_value : Format.formatter -> value -> unit
      val logic_of_value : value -> D.abstract
      val value_of_logic : Ctypes.c_object -> D.abstract -> value
      type m_of_mem
      val tau_of_mem : Formula.tau
      val forall_loc : D.F.pool -> D.F.var list * loc
      val index : loc -> Ctypes.c_object -> D.integer -> loc
      val field : loc -> Cil_types.fieldinfo -> loc
      val load_mem :
        Mvalues.Data.m_of_mem D.F.term -> Ctypes.c_object -> loc -> value
      val store_mem :
        Mvalues.Data.m_of_mem D.F.term ->
        Ctypes.c_object -> loc -> value -> Mvalues.Data.m_of_mem D.F.term
    end
  module type S =
    sig
      module D : Mdata.S
      module A :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val i_neg : Ctypes.c_int -> D.integer -> D.integer
          val i_op :
            Ctypes.c_int ->
            Formula.integer_op -> D.integer -> D.integer -> D.integer
          val i_cmp :
            Ctypes.c_int ->
            Formula.cmp_op -> D.integer -> D.integer -> D.boolean
          val bits_not : Ctypes.c_int -> D.integer -> D.integer
          val bits_and : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_xor : Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_lshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
          val bits_rshift :
            Ctypes.c_int -> D.integer -> D.integer -> D.integer
        end
      module R :
        sig
          module D :
            sig
              module F :
                sig
                  type 'a term = 'D.F.term
                  type pred = D.F.pred
                  val e_int : int -> Formula.integer term
                  val e_call :
                    string ->
                    Formula.abstract term list -> Formula.abstract term
                  val p_call : string -> Formula.abstract term list -> pred
                  val wrap : 'a term -> Formula.abstract term
                  val unwrap : Formula.abstract term -> 'a term
                  val e_true : Formula.boolean term
                  val e_false : Formula.boolean term
                  val e_int : int -> Formula.integer term
                  val e_float : float -> Formula.real term
                  val e_icst : string -> Formula.integer term
                  val e_rcst : string -> Formula.real term
                  val e_int64 : int64 -> Formula.integer term
                  val e_ineg : Formula.integer term -> Formula.integer term
                  val e_rneg : Formula.real term -> Formula.real term
                  val e_iop :
                    Formula.integer_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rop :
                    Formula.real_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.real term
                  val e_icmp :
                    Formula.cmp_op ->
                    Formula.integer term ->
                    Formula.integer term -> Formula.boolean term
                  val e_rcmp :
                    Formula.cmp_op ->
                    Formula.real term ->
                    Formula.real term -> Formula.boolean term
                  val p_icmp :
                    Formula.cmp_op ->
                    Formula.integer term -> Formula.integer term -> pred
                  val p_rcmp :
                    Formula.cmp_op ->
                    Formula.real term -> Formula.real term -> pred
                  val e_bnot : Formula.integer term -> Formula.integer term
                  val e_band :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_bxor :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_lshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val e_rshift :
                    Formula.integer term ->
                    Formula.integer term -> Formula.integer term
                  val integer_of_real :
                    Formula.real term -> Formula.integer term
                  val real_of_integer :
                    Formula.integer term -> Formula.real term
                  val e_bool : Formula.boolean term -> Formula.integer term
                  val e_not : Formula.boolean term -> Formula.boolean term
                  val e_and :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_or :
                    Formula.boolean term ->
                    Formula.boolean term -> Formula.boolean term
                  val e_cond :
                    Formula.boolean term -> 'a term -> 'a term -> 'a term
                  val p_cond : Formula.boolean term -> pred -> pred -> pred
                  val p_true : pred
                  val p_false : pred
                  val p_bool : Formula.boolean term -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type var = D.F.var
                  type pool = D.F.pool
                  val pool : unit -> pool
                  val fresh : pool -> string -> Formula.kind -> var
                  val freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = D.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl :
                    Format.formatter -> pred Formula.declaration -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                end
              type format = Formula.m_format F.term
              type abstract = Formula.abstract F.term
              type integer = Formula.integer F.term
              type real = Formula.real F.term
              type boolean = Formula.boolean F.term
              type record = Formula.m_array F.term
              type urecord = Formula.m_array F.term
              type array = Formula.m_array F.term
              type set = Formula.m_set F.term
              type name = Formula.integer F.term
              type pointer = Formula.m_pointer F.term
              val pp_kind : Format.formatter -> Mdata.kind -> unit
              type interval =
                D.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'D.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              val pp_interval : Format.formatter -> interval -> unit
              val e_app0 : string -> 'F.term
              val e_app1 : string -> 'F.term -> 'F.term
              val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
              val e_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val e_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
              val p_app0 : string -> F.pred
              val p_app1 : string -> 'F.term -> F.pred
              val p_app2 : string -> 'F.term -> 'F.term -> F.pred
              val p_app3 :
                string -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app4 :
                string ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val p_app5 :
                string ->
                'F.term ->
                'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
              val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
              type context = D.context
              type bindings = D.bindings
              class type hint =
                object
                  method capture : F.var list -> unit
                  method has_var : F.var list -> bool
                  method pretty : Format.formatter -> unit
                  method subst : F.var -> Formula.abstract F.term -> unit
                end
              val closed : bindings
              val close : bindings -> F.pred -> F.pred
              val capture : hint list -> bindings -> unit
              val push : string -> F.pool -> bindings -> hint list -> context
              val pop : string -> context -> bindings
              val kill : string -> context -> unit
              val flush : string -> context -> F.pred -> F.pred
              val term_such_that :
                Formula.tau -> ('F.term -> F.pred) -> 'F.term
              val forall : F.var list -> F.pred -> F.pred
              val exists : F.var list -> F.pred -> F.pred
              val subst : F.var -> 'F.term -> F.pred -> F.pred
              val fresh : string -> Mdata.vkind -> F.var
              val alpha : F.var -> F.var option
              val pool : unit -> F.pool
              val vkind_of_var : F.var -> Mdata.vkind
              val has_vars : F.var list -> F.pred -> bool
              type substitution = D.substitution
              val apply : substitution -> 'F.term -> 'F.term
              type havoc =
                D.havoc =
                  Fresh of F.var
                | Update of F.var * (substitution -> Formula.abstract F.term)
              val havoc_static : havoc list -> F.pred -> F.pred
              val havoc_inductive : havoc list -> F.pred -> F.pred
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : F.pred Formula.declaration -> unit
              val iter :
                Formula.section ->
                (F.pred Formula.declaration -> unit) -> unit
              val iter_all : (F.pred Formula.declaration -> unit) -> unit
              val dummy : unit -> F.pred
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare : t -> string -> F.pred Formula.item
                end
              module Register :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varinfo.H.key
                      type 'a t = 'D.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = D.Varaddr.H.key
                      type 'a t = 'D.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = D.Fieldinfo.H.key
                      type 'a t = 'D.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = D.Compinfo.H.key
                      type 'a t = 'D.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = D.Arrayinfo.H.key
                      type 'a t = 'D.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = D.Logicvar.H.key
                      type 'a t = 'D.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Log.source option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
              val modulo : Ctypes.c_int -> integer -> integer
              val guard : Ctypes.c_int -> integer -> F.pred
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              val round : Ctypes.c_float -> real -> real
              val f_guard : Ctypes.c_float -> real -> F.pred
              val f_convert :
                Ctypes.c_float -> Ctypes.c_float -> real -> real
              val has_type : abstract -> Cil_types.logic_type -> F.pred
              val get_range_index : array -> interval -> abstract
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val equal_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer_bool : pointer -> pointer -> boolean
              val le_pointer_bool : pointer -> pointer -> boolean
              val lt_pointer : pointer -> pointer -> F.pred
              val le_pointer : pointer -> pointer -> F.pred
              val minus_pointer : pointer -> pointer -> integer
              val is_null : pointer -> boolean
              val null : pointer
              val tau_of_object : Ctypes.c_object -> Formula.tau
              val tau_of_ctype : Cil_types.typ -> Formula.tau
              val int_format : format
              val real_format : format
              val pointer_format : format
              val record_format : format
              val urecord_format : format
              val array_format : format -> format
              val format_of_object : Ctypes.c_object -> format
              val decode : format -> abstract -> 'F.term
              val encode : format -> 'F.term -> abstract
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
              val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
              val eq_record :
                Cil_types.compinfo -> record -> record -> F.pred
            end
          val f_neg : Ctypes.c_float -> D.real -> D.real
          val f_op :
            Ctypes.c_float -> Formula.real_op -> D.real -> D.real -> D.real
          val f_cmp :
            Ctypes.c_float -> Formula.cmp_op -> D.real -> D.real -> D.boolean
        end
      type loc
      val loc_of_pointer : Ctypes.c_object -> D.pointer -> loc
      val pointer_of_loc : loc -> D.pointer
      val cast_loc_to_int : Cil_types.typ -> loc -> Ctypes.c_int -> D.integer
      val cast_int_to_loc : Ctypes.c_int -> D.integer -> Cil_types.typ -> loc
      val pp_loc : Format.formatter -> loc -> unit
      type value =
          V_int of Ctypes.c_int * D.integer
        | V_float of Ctypes.c_float * D.real
        | V_pointer of Cil_types.typ * loc
        | V_record of Cil_types.compinfo * D.record
        | V_union of Cil_types.compinfo * D.urecord
        | V_array of Ctypes.arrayinfo * D.array
      val pp_value : Format.formatter -> value -> unit
      val logic_of_value : value -> D.abstract
      val value_of_logic : Ctypes.c_object -> D.abstract -> value
      type mem
      val cvar : Mvalues.S.mem -> Cil_types.varinfo -> loc
      val shift : loc -> Ctypes.c_object -> D.integer -> loc
      val index : loc -> Ctypes.c_object -> D.integer -> loc
      val startof : loc -> Ctypes.c_object -> loc
      val field : loc -> Cil_types.fieldinfo -> loc
      val load : Mvalues.S.mem -> Ctypes.c_object -> loc -> value
      val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> loc -> loc
    end
end