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