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 : 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 : mem -> Ctypes.c_object -> loc -> value
  val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> loc -> loc
  type frame
  val new_frame :
    Kernel_function.t ->
    m_here:mem option ->
    m_pre:mem option -> m_post:mem option -> D.F.var option -> Mlogic.S.frame
  val mem_at : Mlogic.S.frame -> Clabels.c_label -> mem
  val result : Mlogic.S.frame -> D.F.var * Cil_types.typ
  val exit_status : Mlogic.S.frame -> D.F.var
  val set_exit_status : Mlogic.S.frame -> D.F.var -> Mlogic.S.frame
  val get_exit_status : Mlogic.S.frame -> D.F.var option
  val base_address : mem -> loc -> loc
  val block_length : mem -> loc -> Formula.integer D.F.term
  val valid : mem -> loc D.assigned -> D.F.pred
  val separated : loc D.assigned -> loc D.assigned -> D.F.pred
  type closure
  val userdef_frame : unit -> Mlogic.S.frame
  val userdef_signature :
    Mlogic.S.frame ->
    Formula.abstract D.F.term list ->
    D.F.pred list -> D.F.var list * Mlogic.S.closure list
  val label_at_closure : Mlogic.S.closure -> string
  val userdef_closure : mem -> Mlogic.S.closure -> Formula.abstract D.F.term
  val pp_closure : Format.formatter -> Mlogic.S.closure -> unit
end