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