sig
  type var = M.F.var
  type 'a term = 'M.F.term
  type pred = M.F.pred
  type abstract = Formula.m_abstract term
  type integer = Formula.m_integer term
  type real = Formula.m_real term
  type boolean = Formula.m_boolean term
  type record = Formula.m_record term
  type urecord = Formula.m_array term
  type array = Formula.m_array term
  type set = Formula.m_set term
  type name = Formula.m_integer term
  type decl = (var, abstract, pred) Formula.declaration
  val e_int : int -> integer
  val e_call : string -> abstract list -> abstract
  val p_call : string -> abstract list -> pred
  val wrap : 'a term -> abstract
  val unwrap : abstract -> 'a term
  val clear : unit -> unit
  val on_clear : (unit -> unit) -> unit
  val fresh_name : string -> string -> string
  val add_declaration : decl -> unit
  val has_declaration : string -> bool
  val iter_all : (string -> unit) -> (decl -> unit) -> unit
  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 -> Lexing.position 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 -> decl
      val on_definition : (t -> decl -> 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 -> Lexing.position 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 -> (var, abstract, pred) Formula.item
    end
  module DRegister :
    functor (D : Declarator->
      sig
        type t = D.t
        val define : t -> unit
        val get_definition : t -> decl
        val on_definition : (t -> decl -> unit) -> unit
      end
  module Varinfo :
    sig
      type t = Cil_types.varinfo
      module H :
        sig
          type key = M.F.Varinfo.H.key
          type 'a t = 'M.F.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 -> Lexing.position 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 = M.F.Varaddr.H.key
          type 'a t = 'M.F.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 -> Lexing.position 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 = M.F.Fieldinfo.H.key
          type 'a t = 'M.F.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 -> Lexing.position 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 = M.F.Compinfo.H.key
          type 'a t = 'M.F.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 -> Lexing.position 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 = M.F.Arrayinfo.H.key
          type 'a t = 'M.F.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 -> Lexing.position 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 = M.F.Logicvar.H.key
          type 'a t = 'M.F.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 -> Lexing.position option
      val pp_title : Format.formatter -> t -> unit
      val pp_descr : Format.formatter -> t -> unit
    end
  module LTypeinfo :
    sig
      type t = Cil_types.logic_type
      module H :
        sig
          type key = M.F.LTypeinfo.H.key
          type 'a t = 'M.F.LTypeinfo.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 -> Lexing.position option
      val pp_title : Format.formatter -> t -> unit
      val pp_descr : Format.formatter -> t -> unit
    end
  module Cobject :
    sig
      type t = Ctypes.c_object
      module H :
        sig
          type key = M.F.Cobject.H.key
          type 'a t = 'M.F.Cobject.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 -> Lexing.position option
      val pp_title : Format.formatter -> t -> unit
      val pp_descr : Format.formatter -> t -> unit
    end
  module ArrayDim :
    sig
      type t = Ctypes.c_object * int
      module H :
        sig
          type key = M.F.ArrayDim.H.key
          type 'a t = 'M.F.ArrayDim.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 -> Lexing.position option
      val pp_title : Format.formatter -> t -> unit
      val pp_descr : Format.formatter -> t -> unit
    end
  val adt_decl : Cil_types.logic_type_info -> string
  val pp_tau : Format.formatter -> Formula.tau -> unit
  val e_true : boolean
  val e_false : boolean
  val e_float : float -> real
  val e_icst : string -> integer
  val e_rcst : string -> real
  val e_int64 : int64 -> integer
  val e_ineg : integer -> integer
  val e_rneg : real -> real
  val e_iop : Formula.int_op -> integer -> integer -> integer
  val e_rop : Formula.real_op -> real -> real -> real
  val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
  val e_rcmp : Formula.cmp_op -> real -> real -> boolean
  val p_icmp : Formula.cmp_op -> integer -> integer -> pred
  val p_rcmp : Formula.cmp_op -> real -> real -> pred
  val e_bnot : integer -> integer
  val e_band : integer -> integer -> integer
  val e_bor : integer -> integer -> integer
  val e_bxor : integer -> integer -> integer
  val e_lshift : integer -> integer -> integer
  val e_rshift : integer -> integer -> integer
  val integer_of_real : real -> integer
  val real_of_integer : integer -> real
  val e_bool : boolean -> integer
  val e_not : boolean -> boolean
  val e_and : boolean -> boolean -> boolean
  val e_or : boolean -> boolean -> boolean
  val e_cond : boolean -> 'a term -> 'a term -> 'a term
  val p_cond : boolean -> pred -> pred -> pred
  val e_getfield : Cil_types.fieldinfo -> record -> abstract
  val e_setfield : Cil_types.fieldinfo -> record -> abstract -> record
  val e_access : array -> integer -> abstract
  val e_update : array -> integer -> abstract -> array
  val p_true : pred
  val p_false : pred
  val p_bool : boolean -> 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 pool = M.F.pool
  val pool : unit -> pool
  val p_fresh : pool -> string -> Formula.kind -> var
  val p_freshen : pool -> var -> var
  val var : var -> 'a term
  val eq_var : var -> var -> bool
  val name_of_var : var -> string
  val basename_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_calls : string -> 'a term -> bool
  val pred_calls : string -> pred -> bool
  val term_closed : 'a term -> bool
  val pred_closed : pred -> bool
  val freevars : pred -> var list
  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 = M.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_section : Format.formatter -> string -> unit
  val pp_term : Format.formatter -> 'a term -> unit
  val pp_pred : Format.formatter -> pred -> unit
  val pp_decl : Format.formatter -> decl -> unit
  val pp_goal : Format.formatter -> string -> pred -> unit
  val pp_vkind : Format.formatter -> Formula.kind -> unit
  val e_app0 : string -> 'a term
  val e_app1 : string -> 'a term -> 'b term
  val e_app2 : string -> 'a term -> 'b term -> 'c term
  val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
  val e_app4 : string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
  val e_app5 :
    string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term -> 'f term
  val p_app0 : string -> pred
  val p_app1 : string -> 'a term -> pred
  val p_app2 : string -> 'a term -> 'b term -> pred
  val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
  val p_app4 : string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
  val p_app5 :
    string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
  val dummy : unit -> pred
  val i_zero : integer
  val r_zero : real
  val i_one : integer
  val i_add : integer -> integer -> integer
  val i_mult : integer -> integer -> integer
  val i_sub : integer -> integer -> integer
  val guard : Ctypes.c_int -> integer -> pred
  val modulo : Ctypes.c_int -> integer -> integer
  val i_convert : Ctypes.c_int -> Ctypes.c_int -> integer -> integer
  type interval =
    M.F.interval = {
    inf : integer option;
    sup : integer option;
  }
  type 'a assigned =
    'M.F.assigned =
      Aloc of Ctypes.c_object * 'a
    | Arange of Ctypes.c_object * 'a * interval
  type havoc =
    M.F.havoc =
      Fresh of var
    | Update of var * ((var * var) list -> abstract)
  val pp_interval : Format.formatter -> interval -> unit
  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 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
  module type Indexed =
    sig
      type t
      val define : t -> unit
      val get_definition : t -> decl
      val on_definition : (t -> decl -> unit) -> unit
      val get_ind : t -> integer
      val has_ind : t -> pred -> bool
    end
  module Dindex :
    functor (I : Identifiable->
      sig
        type t = I.t
        val define : t -> unit
        val get_definition : t -> decl
        val on_definition : (t -> decl -> unit) -> unit
        val get_ind : t -> integer
        val has_ind : t -> pred -> bool
      end
  module Findex :
    sig
      type t = Cil_types.fieldinfo
      val define : t -> unit
      val get_definition : t -> decl
      val on_definition : (t -> decl -> unit) -> unit
      val get_ind : t -> integer
      val has_ind : t -> pred -> bool
    end
  module Xindex :
    sig
      type t = Cil_types.varinfo
      val define : t -> unit
      val get_definition : t -> decl
      val on_definition : (t -> decl -> unit) -> unit
      val get_ind : t -> integer
      val has_ind : t -> pred -> bool
    end
  module Aindex :
    sig
      type t = Cil_types.varinfo
      val define : t -> unit
      val get_definition : t -> decl
      val on_definition : (t -> decl -> unit) -> unit
      val get_ind : t -> integer
      val has_ind : t -> pred -> bool
    end
  module Tindex :
    sig
      type t = Cil_types.compinfo
      val define : t -> unit
      val get_definition : t -> decl
      val on_definition : (t -> decl -> unit) -> unit
      val get_ind : t -> integer
      val has_ind : t -> pred -> bool
    end
  module LTindex :
    sig
      type t = Cil_types.logic_type
      val define : t -> unit
      val get_definition : t -> decl
      val on_definition : (t -> decl -> unit) -> unit
      val get_ind : t -> integer
      val has_ind : t -> pred -> bool
    end
end