functor (F : Formula.S->
  functor
    (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->
    functor
      (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->
      sig
        type decl = F.decl
        type m_mbits
        val t_mbits : Formula.tau
        type mem_bits = Runtime_mem.Create.m_mbits F.term
        type m_alloc
        val t_alloc : Formula.tau
        type mem_alloc = Runtime_mem.Create.m_alloc F.term
        type m_mem
        val t_mem : Formula.tau
        type mem = { vbits : F.var; valloc : F.var; }
        type m_format
        type format = Runtime_mem.Create.m_format F.term
        val mk_iformat : Ctypes.c_int -> string
        val mk_fformat : Ctypes.c_float -> string
        val int_format : '_a F.term
        val real_format : '_a F.term
        val i_format : Ctypes.c_int -> 'F.term
        val f_format : Ctypes.c_float -> 'F.term
        val format_of_addr : '-> 'F.term
        val tcomp_of_comp : Cil_types.compinfo -> Cil_types.typ
        val cil_field_info : Cil_types.fieldinfo -> int * int
        val cil_field_offset : Cil_types.fieldinfo -> int
        val cil_field_size : Cil_types.fieldinfo -> int
        val name_of_var : F.Xindex.t -> F.name
        val name_of_field : F.Findex.t -> F.integer
        val compute_int_mode : Runtime_mem.compute_int_mode
        type 'a tint = F.integer
        module Aint :
          sig
            type 'a t
            val of_int : int -> 'Runtime_mem.Create.??.t
            val of_int64 : Int64.t -> 'Runtime_mem.Create.??.t
            val of_term :
              'Runtime_mem.Create.tint -> 'Runtime_mem.Create.??.t
            val add :
              'Runtime_mem.Create.??.->
              'Runtime_mem.Create.??.-> 'Runtime_mem.Create.??.t
            val sub :
              'Runtime_mem.Create.??.->
              'Runtime_mem.Create.??.-> 'Runtime_mem.Create.??.t
            val cnst_mult :
              Int64.t ->
              'Runtime_mem.Create.??.-> 'Runtime_mem.Create.??.t
            val mult :
              'Runtime_mem.Create.??.->
              'Runtime_mem.Create.??.-> 'Runtime_mem.Create.??.t
            val to_term :
              'Runtime_mem.Create.??.-> 'Runtime_mem.Create.tint
            val eq_pred :
              'Runtime_mem.Create.??.->
              'Runtime_mem.Create.??.-> F.pred
          end
        type m_addr
        type m_offset
        type m_size
        type m_zone
        type t_addr = Runtime_mem.Create.m_addr Runtime_mem.Create.tint
        type t_offset = Runtime_mem.Create.m_offset Runtime_mem.Create.tint
        type t_size = Runtime_mem.Create.m_size Runtime_mem.Create.tint
        type t_zone = Runtime_mem.Create.m_zone F.term
        module Tint :
          sig
            type x_addr
            val xaddr_of_var :
              Runtime_mem.Create.mem_alloc ->
              Cil_types.varinfo -> Runtime_mem.Create.??.x_addr
            val xaddr_of_integer : F.integer -> Runtime_mem.Create.??.x_addr
            val integer_of_xaddr : Runtime_mem.Create.??.x_addr -> F.integer
            val varinfo_of_xaddr :
              Runtime_mem.Create.??.x_addr -> Cil_types.varinfo option
            val pp_addr :
              Format.formatter -> Runtime_mem.Create.??.x_addr -> unit
            val base :
              Runtime_mem.Create.mem_alloc ->
              Runtime_mem.Create.??.x_addr -> Runtime_mem.Create.??.x_addr
            val term_of_xaddr :
              Runtime_mem.Create.??.x_addr -> Runtime_mem.Create.t_addr
            type x_size
            val size_of_int : int -> Runtime_mem.Create.??.x_size
            val size_of_int64 : Int64.t -> Runtime_mem.Create.??.x_size
            val cnst_mult_size :
              Int64.t ->
              Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_size
            val xsize_of_range :
              F.integer ->
              F.integer ->
              Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_size
            val term_of_xsize :
              Runtime_mem.Create.??.x_size -> Runtime_mem.Create.t_size
            val shift_n_elem :
              Runtime_mem.Create.??.x_addr ->
              F.integer ->
              Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_addr
            val shift_field :
              Runtime_mem.Create.??.x_addr ->
              Cil_types.fieldinfo -> Runtime_mem.Create.??.x_addr
            val toffset_of_field :
              ?mode:Runtime_mem.compute_int_mode ->
              Cil_types.fieldinfo -> Runtime_mem.Create.t_offset
            val tsize_of_field :
              ?mode:Runtime_mem.compute_int_mode ->
              Cil_types.fieldinfo -> Runtime_mem.Create.t_size
            type x_zone
            val mk_xzone :
              Runtime_mem.Create.??.x_addr ->
              Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_zone
            val xzone_of_var :
              Runtime_mem.Create.mem_alloc ->
              Cil_types.varinfo ->
              Runtime_mem.Create.??.x_size -> Runtime_mem.Create.??.x_zone
            val pp_xzone :
              Format.formatter -> Runtime_mem.Create.??.x_zone -> unit
            val term_of_xzone :
              Runtime_mem.Create.??.x_zone ->
              Runtime_mem.Create.m_zone F.term
            val eq_zone :
              Runtime_mem.Create.??.x_zone ->
              Runtime_mem.Create.??.x_zone -> F.pred
            val xzone_disj :
              Runtime_mem.Create.??.x_zone ->
              Runtime_mem.Create.??.x_zone -> F.pred
          end
        val sizeof_c_object :
          Ctypes.c_object -> Runtime_mem.Create.Tint.x_size
        type m_bits
        type t_bits = Runtime_mem.Create.m_bits F.term
        type m_dzone
        type dzone = Runtime_mem.Create.m_dzone F.term
        module RtLib :
          sig
            val rt_global : F.name -> F.pred
            val rt_vsize : F.name -> Runtime_mem.Create.t_size
            val load :
              Runtime_mem.Create.mem_bits ->
              Runtime_mem.Create.t_zone -> Runtime_mem.Create.t_bits
            val store :
              Runtime_mem.Create.mem_bits ->
              Runtime_mem.Create.t_addr ->
              Runtime_mem.Create.t_bits -> Runtime_mem.Create.mem_bits
            val havoc :
              Runtime_mem.Create.mem_bits ->
              Runtime_mem.Create.t_zone -> Runtime_mem.Create.mem_bits
            val to_bits :
              Runtime_mem.Create.format ->
              F.abstract -> Runtime_mem.Create.t_bits
            val from_bits :
              Runtime_mem.Create.t_bits ->
              Runtime_mem.Create.format -> F.abstract
            val alloc :
              Runtime_mem.Create.mem_alloc ->
              F.name -> Runtime_mem.Create.mem_alloc
            val block_length :
              Runtime_mem.Create.mem_alloc ->
              Runtime_mem.Create.t_addr -> Runtime_mem.Create.t_size
            val valid :
              Runtime_mem.Create.mem_alloc ->
              Runtime_mem.Create.t_zone -> F.pred
            val is_havoc :
              Runtime_mem.Create.mem_alloc ->
              Runtime_mem.Create.mem_bits ->
              Runtime_mem.Create.dzone ->
              Runtime_mem.Create.mem_bits -> F.pred
            val free :
              Runtime_mem.Create.mem_alloc ->
              F.name -> Runtime_mem.Create.mem_alloc
            val zs_empty : Runtime_mem.Create.dzone
            val zs_singleton :
              Runtime_mem.Create.t_zone -> Runtime_mem.Create.dzone
            val zs_union :
              Runtime_mem.Create.dzone ->
              Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone
            val zs_incl :
              Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone -> F.pred
          end
        val z_from_bits :
          Runtime_mem.Create.t_bits -> Runtime_mem.Create.format -> F.integer
        val real_from_bits :
          Runtime_mem.Create.t_bits -> Runtime_mem.Create.format -> F.real
        module Model :
          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
            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 = Runtime_mem.Create.Tint.x_addr
            val pp_loc :
              Format.formatter -> Runtime_mem.Create.Tint.x_addr -> unit
            val cast_loc_to_int :
              '->
              Runtime_mem.Create.Tint.x_addr ->
              Ctypes.c_int -> Runtime_mem.Create.Model.F.integer
            val cast_int_to_loc :
              Ctypes.c_int ->
              Runtime_mem.Create.Model.F.integer ->
              '-> Runtime_mem.Create.Model.loc
            val null : Runtime_mem.Create.Tint.x_addr
            val is_null :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Model.F.boolean
            val minus_loc :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Tint.x_addr ->
              'Runtime_mem.Create.Model.F.term
            val le_loc_bool :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Tint.x_addr ->
              'Runtime_mem.Create.Model.F.term
            val lt_loc_bool :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Tint.x_addr ->
              'Runtime_mem.Create.Model.F.term
            val equal_loc_bool :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Tint.x_addr ->
              'Runtime_mem.Create.Model.F.term
            val le_loc :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Model.F.pred
            val lt_loc :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Model.F.pred
            val equal_loc :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Model.F.pred
            val term_of_loc :
              Runtime_mem.Create.Tint.x_addr ->
              Runtime_mem.Create.Model.F.abstract
            val loc_of_term :
              '->
              Runtime_mem.Create.Model.F.abstract ->
              Runtime_mem.Create.Tint.x_addr
            val tau_of_loc : Formula.tau
          end
        val startof : '-> '-> 'a
        val cast_loc_to_loc : '-> '-> '-> 'c
        val tau_of_dzone : Formula.tau
        val xzone_assigned :
          Runtime_mem.Create.Tint.x_addr F.assigned ->
          Runtime_mem.Create.Tint.x_zone
        val dzone_assigned :
          '->
          Runtime_mem.Create.Tint.x_addr F.assigned ->
          Runtime_mem.Create.dzone
        val dzone_empty : unit -> Runtime_mem.Create.dzone
        val dzone_subset :
          Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone -> F.pred
        val dzone_union :
          Runtime_mem.Create.dzone ->
          Runtime_mem.Create.dzone -> Runtime_mem.Create.dzone
        val effect_supported : bool
        val int_format_for_hyp : Ctypes.c_object -> 'F.term option
        val add_int_format_hyp :
          'F.term -> Ctypes.c_object -> F.pred -> F.pred
        module VarDecl :
          sig
            type t = Cil_types.varinfo
            val define : t -> unit
            val get_definition : t -> F.decl
            val on_definition : (t -> F.decl -> unit) -> unit
          end
        module Fields :
          sig
            type t = Cil_types.fieldinfo
            val define : t -> unit
            val get_definition : t -> F.decl
            val on_definition : (t -> F.decl -> unit) -> unit
          end
        module V :
          sig
            module F :
              sig
                type var = Model.F.var
                type 'a term = 'Model.F.term
                type pred = Model.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 = Model.F.Varinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                        type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                        type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Cobject.H.key
                        type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                        type 'a t = 'Model.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 = Model.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 = Model.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 =
                  Model.F.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'Model.F.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                type havoc =
                  Model.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
            module A :
              sig
                module F :
                  sig
                    type var = Model.F.var
                    type 'a term = 'Model.F.term
                    type pred = Model.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 = Model.F.Varinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                            type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                            type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Cobject.H.key
                            type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                            type 'a t = 'Model.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 = Model.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 = Model.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 =
                      Model.F.interval = {
                      inf : integer option;
                      sup : integer option;
                    }
                    type 'a assigned =
                      'Model.F.assigned =
                        Aloc of Ctypes.c_object * 'a
                      | Arange of Ctypes.c_object * 'a * interval
                    type havoc =
                      Model.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 = Model.F.var
                    type 'a term = 'Model.F.term
                    type pred = Model.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 = Model.F.Varinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                            type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                            type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Cobject.H.key
                            type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                            type 'a t = 'Model.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 = Model.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 = Model.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 =
                      Model.F.interval = {
                      inf : integer option;
                      sup : integer option;
                    }
                    type 'a assigned =
                      'Model.F.assigned =
                        Aloc of Ctypes.c_object * 'a
                      | Arange of Ctypes.c_object * 'a * interval
                    type havoc =
                      Model.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 = Model.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 =
              Datalib.Cvalues(Model).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
          end
        module L :
          sig
            module F :
              sig
                type var = V.F.var
                type 'a term = 'V.F.term
                type pred = V.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 = V.F.Varinfo.H.key
                        type 'a t = 'V.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 = V.F.Varaddr.H.key
                        type 'a t = 'V.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 = V.F.Fieldinfo.H.key
                        type 'a t = 'V.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 = V.F.Compinfo.H.key
                        type 'a t = 'V.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 = V.F.Arrayinfo.H.key
                        type 'a t = 'V.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 = V.F.Logicvar.H.key
                        type 'a t = 'V.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 = V.F.LTypeinfo.H.key
                        type 'a t = 'V.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 = V.F.Cobject.H.key
                        type 'a t = 'V.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 = V.F.ArrayDim.H.key
                        type 'a t = 'V.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 = V.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 = V.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 =
                  V.F.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'V.F.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                type havoc =
                  V.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 = Datalib.Create(V).context
            type bindings = Datalib.Create(V).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
        module Data :
          sig
            module F :
              sig
                type var = Model.F.var
                type 'a term = 'Model.F.term
                type pred = Model.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 = Model.F.Varinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                        type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                        type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Cobject.H.key
                        type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                        type 'a t = 'Model.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 = Model.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 = Model.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 =
                  Model.F.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'Model.F.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                type havoc =
                  Model.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
            module A :
              sig
                module F :
                  sig
                    type var = Model.F.var
                    type 'a term = 'Model.F.term
                    type pred = Model.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 = Model.F.Varinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                            type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                            type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Cobject.H.key
                            type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                            type 'a t = 'Model.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 = Model.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 = Model.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 =
                      Model.F.interval = {
                      inf : integer option;
                      sup : integer option;
                    }
                    type 'a assigned =
                      'Model.F.assigned =
                        Aloc of Ctypes.c_object * 'a
                      | Arange of Ctypes.c_object * 'a * interval
                    type havoc =
                      Model.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 = Model.F.var
                    type 'a term = 'Model.F.term
                    type pred = Model.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 = Model.F.Varinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                            type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                            type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                            type 'a t = 'Model.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 = Model.F.Cobject.H.key
                            type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                            type 'a t = 'Model.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 = Model.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 = Model.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 =
                      Model.F.interval = {
                      inf : integer option;
                      sup : integer option;
                    }
                    type 'a assigned =
                      'Model.F.assigned =
                        Aloc of Ctypes.c_object * 'a
                      | Arange of Ctypes.c_object * 'a * interval
                    type havoc =
                      Model.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 = Model.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 =
              Datalib.Cvalues(Model).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
            type m_of_mem = Runtime_mem.Create.m_mbits
            val tau_of_mem : Formula.tau
            val forall_loc :
              F.pool -> F.var list * Runtime_mem.Create.Tint.x_addr
            val global : Runtime_mem.Create.VarDecl.t -> unit
            val cvar :
              Runtime_mem.Create.mem ->
              Runtime_mem.Create.VarDecl.t -> Runtime_mem.Create.Tint.x_addr
            val inner_loc : '-> 'b
            val lvar : '-> Cil_types.logic_var -> F.var -> loc
            val shift : loc -> Ctypes.c_object -> F.integer -> loc
            val index : loc -> Ctypes.c_object -> F.integer -> loc
            val field :
              loc ->
              Runtime_mem.Create.Fields.t -> Runtime_mem.Create.Tint.x_addr
            val value_of_bits :
              (Ctypes.c_object -> Runtime_mem.Create.t_bits -> value)
              Pervasives.ref
            val bits_of_value :
              (Ctypes.c_object -> value -> Runtime_mem.Create.t_bits)
              Pervasives.ref
            val load_mem :
              Runtime_mem.Create.mem_bits ->
              Ctypes.c_object -> Runtime_mem.Create.Tint.x_addr -> value
            val store_mem :
              Runtime_mem.Create.mem_bits ->
              Ctypes.c_object ->
              Runtime_mem.Create.Tint.x_addr ->
              value -> Runtime_mem.Create.mem_bits
          end
        module DF :
          sig
            val record_format : Cil_types.compinfo -> 'Data.F.term
            val array_format : Ctypes.arrayinfo -> 'Data.F.term
            val loaded : Ctypes.c_object -> unit
            val stored : Ctypes.c_object -> unit
          end
        val load :
          Runtime_mem.Create.mem ->
          Ctypes.c_object ->
          Runtime_mem.Create.Tint.x_addr -> Runtime_mem.Create.Data.value
        val store :
          Runtime_mem.Create.mem ->
          Runtime_mem.Create.Tint.x_addr ->
          Ctypes.c_object ->
          Runtime_mem.Create.Data.value -> Runtime_mem.Create.mem_bits
        module F :
          sig
            type var = Model.F.var
            type 'a term = 'Model.F.term
            type pred = Model.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 = Model.F.Varinfo.H.key
                    type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                    type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                    type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                    type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                    type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                    type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                    type 'a t = 'Model.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 = Model.F.Cobject.H.key
                    type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                    type 'a t = 'Model.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 = Model.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 = Model.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 =
              Model.F.interval = {
              inf : integer option;
              sup : integer option;
            }
            type 'a assigned =
              'Model.F.assigned =
                Aloc of Ctypes.c_object * 'a
              | Arange of Ctypes.c_object * 'a * interval
            type havoc =
              Model.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
        module A :
          sig
            module F :
              sig
                type var = Model.F.var
                type 'a term = 'Model.F.term
                type pred = Model.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 = Model.F.Varinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                        type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                        type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Cobject.H.key
                        type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                        type 'a t = 'Model.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 = Model.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 = Model.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 =
                  Model.F.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'Model.F.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                type havoc =
                  Model.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 = Model.F.var
                type 'a term = 'Model.F.term
                type pred = Model.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 = Model.F.Varinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Varaddr.H.key
                        type 'a t = 'Model.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 = Model.F.Fieldinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Compinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Arrayinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Logicvar.H.key
                        type 'a t = 'Model.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 = Model.F.LTypeinfo.H.key
                        type 'a t = 'Model.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 = Model.F.Cobject.H.key
                        type 'a t = 'Model.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 = Model.F.ArrayDim.H.key
                        type 'a t = 'Model.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 = Model.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 = Model.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 =
                  Model.F.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'Model.F.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                type havoc =
                  Model.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 = Model.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 =
          Datalib.Cvalues(Model).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
        type m_of_mem = m_mbits
        val tau_of_mem : Formula.tau
        val forall_loc : F.pool -> F.var list * Tint.x_addr
        val global : VarDecl.t -> unit
        val cvar : mem -> VarDecl.t -> Tint.x_addr
        val inner_loc : '-> 'b
        val lvar : '-> Cil_types.logic_var -> F.var -> loc
        val shift : loc -> Ctypes.c_object -> F.integer -> loc
        val index : loc -> Ctypes.c_object -> F.integer -> loc
        val field : loc -> Fields.t -> Tint.x_addr
        val value_of_bits : (Ctypes.c_object -> t_bits -> value) ref
        val bits_of_value : (Ctypes.c_object -> value -> t_bits) ref
        val load_mem : mem_bits -> Ctypes.c_object -> Tint.x_addr -> value
        val store_mem :
          mem_bits -> Ctypes.c_object -> Tint.x_addr -> value -> mem_bits
        val format_of_compinfo :
          Cil_types.compinfo -> 'Runtime_mem.Create.Data.F.term
        val format_of_array :
          Ctypes.arrayinfo -> 'Runtime_mem.Create.Data.F.term
        val rt_format_of_ctype :
          Ctypes.c_object -> 'Runtime_mem.Create.Data.F.term
        val value_of_bits :
          Ctypes.c_object ->
          Runtime_mem.Create.t_bits -> Runtime_mem.Create.Data.value
        val bits_of_value : '-> value -> Runtime_mem.Create.t_bits
        val mem : unit -> Runtime_mem.Create.mem
        val valid :
          Runtime_mem.Create.mem ->
          Runtime_mem.Create.Tint.x_addr F.assigned -> F.pred
        val separated :
          '->
          Runtime_mem.Create.Tint.x_addr F.assigned ->
          Runtime_mem.Create.Tint.x_addr F.assigned -> F.pred
        val tbits_of_var : F.var -> Runtime_mem.Create.t_bits
        val subst_havoc :
          Runtime_mem.Create.mem ->
          Runtime_mem.Create.Tint.x_addr F.assigned -> F.havoc list
        val assigns_goal :
          Runtime_mem.Create.mem ->
          Runtime_mem.Create.Tint.x_addr F.assigned list ->
          Runtime_mem.Create.mem -> F.pred
        val assigns_supported : bool
        val base_address :
          Runtime_mem.Create.mem ->
          Runtime_mem.Create.Tint.x_addr -> Runtime_mem.Create.Tint.x_addr
        val block_length :
          Runtime_mem.Create.mem ->
          Runtime_mem.Create.Tint.x_addr -> Runtime_mem.Create.t_size
        type closure = Mem | Alloc
        val pp_closure :
          Format.formatter -> Runtime_mem.Create.closure -> unit
        val userdef_mem_signature :
          Runtime_mem.Create.mem -> (F.var * Runtime_mem.Create.closure) list
        val userdef_mem_apply :
          Runtime_mem.Create.mem -> Runtime_mem.Create.closure -> F.abstract
        type formal = unit
        val pp_formal : '-> '-> unit
        val userdef_is_ref_param : Cil_types.logic_var -> bool
        val userdef_ref_signature :
          Runtime_mem.Create.mem ->
          (F.var * Cil_types.logic_var * Runtime_mem.Create.formal) list
        val userdef_ref_apply :
          Runtime_mem.Create.mem -> Runtime_mem.Create.formal -> loc -> value
        val userdef_ref_has_cvar : Cil_types.logic_var -> bool
        val update :
          at:Runtime_mem.Create.mem ->
          here:Runtime_mem.Create.mem ->
          Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
        val quantify :
          Runtime_mem.Create.mem ->
          Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
        val subst_lval :
          Runtime_mem.Create.mem ->
          Ctypes.c_object ->
          Runtime_mem.Create.Tint.x_addr ->
          Runtime_mem.Create.Data.value ->
          Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
        val local_scope :
          Runtime_mem.Create.mem ->
          F.Xindex.t list ->
          Mcfg.scope ->
          Runtime_mem.Create.L.F.pred -> Runtime_mem.Create.L.F.pred
        val global_scope : '-> '-> 'b
      end