functor (D : Mdata.S->
  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