sig
  module F : Formula.S
  module A :
    sig
      module F :
        sig
          type var = F.var
          type 'a term = 'F.term
          type pred = 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 = F.Varinfo.H.key
                  type 'a t = '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 = F.Varaddr.H.key
                  type 'a t = '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 = F.Fieldinfo.H.key
                  type 'a t = '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 = F.Compinfo.H.key
                  type 'a t = '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 = F.Arrayinfo.H.key
                  type 'a t = '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 = F.Logicvar.H.key
                  type 'a t = '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 = F.LTypeinfo.H.key
                  type 'a t = '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 = F.Cobject.H.key
                  type 'a t = '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 = F.ArrayDim.H.key
                  type 'a t = '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 = 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 = 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 =
            F.interval = {
            inf : integer option;
            sup : integer option;
          }
          type 'a assigned =
            'F.assigned =
              Aloc of Ctypes.c_object * 'a
            | Arange of Ctypes.c_object * 'a * interval
          type havoc =
            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
      val i_neg : Ctypes.c_int -> F.integer -> F.integer
      val i_op :
        Ctypes.c_int -> Formula.int_op -> F.integer -> F.integer -> F.integer
      val i_cmp :
        Ctypes.c_int -> Formula.cmp_op -> F.integer -> F.integer -> F.boolean
      val bits_not : Ctypes.c_int -> F.integer -> F.integer
      val bits_and : Ctypes.c_int -> F.integer -> F.integer -> F.integer
      val bits_or : Ctypes.c_int -> F.integer -> F.integer -> F.integer
      val bits_xor : Ctypes.c_int -> F.integer -> F.integer -> F.integer
      val bits_lshift : Ctypes.c_int -> F.integer -> F.integer -> F.integer
      val bits_rshift : Ctypes.c_int -> F.integer -> F.integer -> F.integer
    end
  module R :
    sig
      module F :
        sig
          type var = F.var
          type 'a term = 'F.term
          type pred = 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 = F.Varinfo.H.key
                  type 'a t = '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 = F.Varaddr.H.key
                  type 'a t = '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 = F.Fieldinfo.H.key
                  type 'a t = '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 = F.Compinfo.H.key
                  type 'a t = '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 = F.Arrayinfo.H.key
                  type 'a t = '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 = F.Logicvar.H.key
                  type 'a t = '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 = F.LTypeinfo.H.key
                  type 'a t = '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 = F.Cobject.H.key
                  type 'a t = '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 = F.ArrayDim.H.key
                  type 'a t = '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 = 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 = 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 =
            F.interval = {
            inf : integer option;
            sup : integer option;
          }
          type 'a assigned =
            'F.assigned =
              Aloc of Ctypes.c_object * 'a
            | Arange of Ctypes.c_object * 'a * interval
          type havoc =
            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
      val f_neg : Ctypes.c_float -> F.real -> F.real
      val f_op :
        Ctypes.c_float -> Formula.real_op -> F.real -> F.real -> F.real
      val f_cmp :
        Ctypes.c_float -> Formula.cmp_op -> F.real -> F.real -> F.boolean
    end
  type loc
  val tau_of_loc : Formula.tau
  val term_of_loc : loc -> F.abstract
  val loc_of_term : Ctypes.c_object -> F.abstract -> loc
  val equal_loc_bool : loc -> loc -> F.boolean
  val lt_loc_bool : loc -> loc -> F.boolean
  val le_loc_bool : loc -> loc -> F.boolean
  val lt_loc : loc -> loc -> F.pred
  val le_loc : loc -> loc -> F.pred
  val equal_loc : loc -> loc -> F.pred
  val minus_loc : loc -> loc -> F.integer
  val is_null : loc -> F.boolean
  val null : loc
  val cast_loc_to_int : Cil_types.typ -> loc -> Ctypes.c_int -> F.integer
  val cast_int_to_loc : Ctypes.c_int -> F.integer -> Cil_types.typ -> loc
  val pp_loc : Format.formatter -> loc -> unit
  type value =
      V_int of Ctypes.c_int * F.integer
    | V_float of Ctypes.c_float * F.real
    | V_pointer of Ctypes.c_object * loc
    | V_record of Cil_types.compinfo * F.record
    | V_union of Cil_types.compinfo * F.urecord
    | V_array of Ctypes.arrayinfo * F.array
  val pp_value : Format.formatter -> value -> unit
  val equal : Ctypes.c_object -> F.abstract -> F.abstract -> F.pred
  val eq_array : Ctypes.arrayinfo -> F.array -> F.array -> F.pred
  val eq_record : Cil_types.compinfo -> F.record -> F.record -> F.pred
  val logic_of_value : value -> F.abstract
  val value_of_logic : Ctypes.c_object -> F.abstract -> value
  val tau_of_object : Ctypes.c_object -> Formula.tau
  val tau_of_object_array : Ctypes.c_object -> int -> Formula.tau
  val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
  val pp_tau : Format.formatter -> Formula.tau -> unit
  val symb_is_init : Ctypes.c_object -> string option
  val symb_is_init_range : Ctypes.c_object -> string option
  module L :
    sig
      module F :
        sig
          type var = F.var
          type 'a term = 'F.term
          type pred = 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 = F.Varinfo.H.key
                  type 'a t = '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 = F.Varaddr.H.key
                  type 'a t = '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 = F.Fieldinfo.H.key
                  type 'a t = '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 = F.Compinfo.H.key
                  type 'a t = '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 = F.Arrayinfo.H.key
                  type 'a t = '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 = F.Logicvar.H.key
                  type 'a t = '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 = F.LTypeinfo.H.key
                  type 'a t = '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 = F.Cobject.H.key
                  type 'a t = '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 = F.ArrayDim.H.key
                  type 'a t = '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 = 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 = 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 =
            F.interval = {
            inf : integer option;
            sup : integer option;
          }
          type 'a assigned =
            'F.assigned =
              Aloc of Ctypes.c_object * 'a
            | Arange of Ctypes.c_object * 'a * interval
          type havoc =
            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
      type context
      type bindings
      val closed : bindings
      val close : bindings -> F.pred -> F.pred
      val push : string -> F.pool -> bindings -> 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 -> Formula.kind -> F.var
      val alpha : F.var -> F.var option
      val pool : unit -> F.pool
      val vkind_of_var : F.var -> Formula.kind
      val has_context_vars : F.var list -> F.pred -> bool
      val has_type : F.abstract -> Cil_types.logic_type -> F.pred
      val is_comp : Cil_types.compinfo -> F.abstract -> F.pred
      val is_array : Ctypes.arrayinfo -> F.abstract -> F.pred
      val apply : (F.var * F.var) list -> 'F.term -> 'F.term
      val havoc_static : F.havoc list -> F.pred -> F.pred
      val havoc_inductive : F.havoc list -> F.pred -> F.pred
    end
  type mem
  val mem : unit -> Mvalues.S.mem
  val global : Cil_types.varinfo -> unit
  val cvar : Mvalues.S.mem -> Cil_types.varinfo -> loc
  val shift : loc -> Ctypes.c_object -> F.integer -> loc
  val index : loc -> Ctypes.c_object -> F.integer -> loc
  val startof : loc -> Ctypes.c_object -> loc
  val field : loc -> Cil_types.fieldinfo -> loc
  val load : Mvalues.S.mem -> Ctypes.c_object -> loc -> value
  val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> loc -> loc
end