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
        val unsupported :
          ?model:string ->
          ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
        type decl = F.decl
        val t_data : Formula.tau
        type m_memory = Formula.m_array
        val t_memory : Formula.tau
        type store = Store_mem.Create.m_memory F.term
        type m_alloc = Formula.m_array
        val t_alloc : Formula.tau
        type alloc = Store_mem.Create.m_alloc F.term
        type m_dzone
        type dzone = Store_mem.Create.m_dzone F.term
        val data_of_int : Ctypes.c_int -> 'F.term -> 'F.term
        val int_of_data : Ctypes.c_int -> 'F.term -> 'F.term
        val data_of_float : Ctypes.c_float -> 'F.term -> 'F.term
        val float_of_data : Ctypes.c_float -> 'F.term -> 'F.term
        val addr_of_data :
          Formula.m_abstract F.term -> Formula.m_integer F.term
        val data_of_addr : F.integer -> Formula.m_abstract F.term
        val model_addr : F.integer -> F.integer -> F.integer
        val model_base : F.integer -> F.integer
        val model_offset : F.integer -> F.integer
        val model_addr_shift : F.integer -> F.integer -> F.integer
        val model_valid :
          Store_mem.Create.alloc -> F.integer -> F.integer -> F.pred
        val model_isfresh :
          Store_mem.Create.store ->
          Store_mem.Create.alloc -> F.integer -> F.pred
        val model_alloc :
          Store_mem.Create.alloc ->
          F.integer -> F.integer -> Store_mem.Create.alloc
        val model_free :
          Store_mem.Create.alloc -> F.integer -> Store_mem.Create.alloc
        val model_block : Store_mem.Create.alloc -> F.integer -> F.integer
        val model_zempty : Store_mem.Create.dzone
        val model_zunion :
          Store_mem.Create.dzone ->
          Store_mem.Create.dzone -> Store_mem.Create.dzone
        val model_included :
          Store_mem.Create.dzone -> Store_mem.Create.dzone -> F.pred
        val model_zrange :
          F.integer -> F.integer -> F.integer -> Store_mem.Create.dzone
        val model_zrange_of_addr_range :
          F.integer -> F.integer -> F.integer -> Store_mem.Create.dzone
        val model_separated :
          Store_mem.Create.dzone -> Store_mem.Create.dzone -> F.pred
        val model_update_range :
          Store_mem.Create.store ->
          Store_mem.Create.dzone -> F.abstract -> Store_mem.Create.store
        val model_access_range :
          Store_mem.Create.store -> Store_mem.Create.dzone -> F.abstract
        val model_update_havoc :
          Store_mem.Create.store ->
          Store_mem.Create.dzone -> F.abstract -> Store_mem.Create.store
        val model_ishavoc :
          Store_mem.Create.alloc ->
          Store_mem.Create.store ->
          Store_mem.Create.dzone -> Store_mem.Create.store -> F.pred
        type mem = {
          x_store : F.var;
          x_alloc : F.var;
          store : Store_mem.Create.store;
          alloc : Store_mem.Create.alloc;
        }
        val encode : 'F.term -> 'F.term -> 'F.term
        val decode : 'F.term -> 'F.term -> 'F.term
        val sizeof : Ctypes.c_object -> F.integer
        val n_size : F.integer -> Ctypes.c_object -> F.integer
        val add_offset :
          F.integer -> Ctypes.c_object -> F.integer -> F.integer
        val cardinal : F.integer -> F.integer -> F.integer
        val offset_of_field : Cil_datatype.Fieldinfo.t -> F.integer
        module Model :
          sig
            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
            module F :
              sig
                type var = F.var
                type 'a term = 'F.term
                type pred = F.pred
                type abstract = Formula.m_abstract term
                type integer = Formula.m_integer term
                type real = Formula.m_real term
                type boolean = Formula.m_boolean term
                type record = Formula.m_record term
                type urecord = Formula.m_array term
                type array = Formula.m_array term
                type set = Formula.m_set term
                type name = Formula.m_integer term
                type decl = (var, abstract, pred) Formula.declaration
                val e_int : int -> integer
                val e_call : string -> abstract list -> abstract
                val p_call : string -> abstract list -> pred
                val wrap : 'a term -> abstract
                val unwrap : abstract -> 'a term
                val clear : unit -> unit
                val on_clear : (unit -> unit) -> unit
                val fresh_name : string -> string -> string
                val add_declaration : decl -> unit
                val has_declaration : string -> bool
                val iter_all : (string -> unit) -> (decl -> unit) -> unit
                module type Identifiable =
                  sig
                    type t
                    module H : Hashtbl.S
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module type Registry =
                  sig
                    type t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                  end
                module type Declarator =
                  sig
                    type t
                    module H : Hashtbl.S
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                    val clear : unit -> unit
                    val section : Formula.section
                    val declare :
                      t -> string -> (var, abstract, pred) Formula.item
                  end
                module DRegister :
                  functor (D : Declarator->
                    sig
                      type t = D.t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                    end
                module Varinfo :
                  sig
                    type t = Cil_types.varinfo
                    module H :
                      sig
                        type key = F.Varinfo.H.key
                        type 'a t = 'F.Varinfo.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module Varaddr :
                  sig
                    type t = Cil_types.varinfo
                    module H :
                      sig
                        type key = F.Varaddr.H.key
                        type 'a t = 'F.Varaddr.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module Fieldinfo :
                  sig
                    type t = Cil_types.fieldinfo
                    module H :
                      sig
                        type key = F.Fieldinfo.H.key
                        type 'a t = 'F.Fieldinfo.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module Compinfo :
                  sig
                    type t = Cil_types.compinfo
                    module H :
                      sig
                        type key = F.Compinfo.H.key
                        type 'a t = 'F.Compinfo.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module Arrayinfo :
                  sig
                    type t = Ctypes.arrayinfo
                    module H :
                      sig
                        type key = F.Arrayinfo.H.key
                        type 'a t = 'F.Arrayinfo.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module Logicvar :
                  sig
                    type t = Cil_types.logic_var
                    module H :
                      sig
                        type key = F.Logicvar.H.key
                        type 'a t = 'F.Logicvar.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module LTypeinfo :
                  sig
                    type t = Cil_types.logic_type
                    module H :
                      sig
                        type key = F.LTypeinfo.H.key
                        type 'a t = 'F.LTypeinfo.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module Cobject :
                  sig
                    type t = Ctypes.c_object
                    module H :
                      sig
                        type key = F.Cobject.H.key
                        type 'a t = 'F.Cobject.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module ArrayDim :
                  sig
                    type t = Ctypes.c_object * int
                    module H :
                      sig
                        type key = F.ArrayDim.H.key
                        type 'a t = 'F.ArrayDim.H.t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val copy : 'a t -> 'a t
                        val add : 'a t -> key -> '-> unit
                        val remove : 'a t -> key -> unit
                        val find : 'a t -> key -> 'a
                        val find_all : 'a t -> key -> 'a list
                        val replace : 'a t -> key -> '-> unit
                        val mem : 'a t -> key -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                      end
                    val index : t -> H.key
                    val prefix : string
                    val basename : t -> string
                    val location : t -> Lexing.position option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                val adt_decl : Cil_types.logic_type_info -> string
                val pp_tau : Format.formatter -> Formula.tau -> unit
                val e_true : boolean
                val e_false : boolean
                val e_float : float -> real
                val e_icst : string -> integer
                val e_rcst : string -> real
                val e_int64 : int64 -> integer
                val e_ineg : integer -> integer
                val e_rneg : real -> real
                val e_iop : Formula.int_op -> integer -> integer -> integer
                val e_rop : Formula.real_op -> real -> real -> real
                val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
                val e_rcmp : Formula.cmp_op -> real -> real -> boolean
                val p_icmp : Formula.cmp_op -> integer -> integer -> pred
                val p_rcmp : Formula.cmp_op -> real -> real -> pred
                val e_bnot : integer -> integer
                val e_band : integer -> integer -> integer
                val e_bor : integer -> integer -> integer
                val e_bxor : integer -> integer -> integer
                val e_lshift : integer -> integer -> integer
                val e_rshift : integer -> integer -> integer
                val integer_of_real : real -> integer
                val real_of_integer : integer -> real
                val e_bool : boolean -> integer
                val e_not : boolean -> boolean
                val e_and : boolean -> boolean -> boolean
                val e_or : boolean -> boolean -> boolean
                val e_cond : boolean -> 'a term -> 'a term -> 'a term
                val p_cond : boolean -> pred -> pred -> pred
                val e_getfield : Cil_types.fieldinfo -> record -> abstract
                val e_setfield :
                  Cil_types.fieldinfo -> record -> abstract -> record
                val e_access : array -> integer -> abstract
                val e_update : array -> integer -> abstract -> array
                val p_true : pred
                val p_false : pred
                val p_bool : boolean -> pred
                val p_and : pred -> pred -> pred
                val p_or : pred -> pred -> pred
                val p_xor : pred -> pred -> pred
                val p_not : pred -> pred
                val p_implies : pred -> pred -> pred
                val p_iff : pred -> pred -> pred
                val p_eq : 'a term -> 'a term -> pred
                val p_neq : 'a term -> 'a term -> pred
                val p_conj : pred list -> pred
                val p_disj : pred list -> pred
                val p_named : string -> pred -> pred
                val is_true : pred -> bool
                val is_false : pred -> bool
                val huge_term : int -> 'a term -> bool
                val huge_pred : int -> pred -> bool
                type pool = F.pool
                val pool : unit -> pool
                val p_fresh : pool -> string -> Formula.kind -> var
                val p_freshen : pool -> var -> var
                val var : var -> 'a term
                val eq_var : var -> var -> bool
                val name_of_var : var -> string
                val basename_of_var : var -> string
                val tau_of_var : var -> Formula.tau
                val kind_of_var : var -> Formula.kind
                val term_has_var : var list -> 'a term -> bool
                val pred_has_var : var list -> pred -> bool
                val term_calls : string -> 'a term -> bool
                val pred_calls : string -> pred -> bool
                val term_closed : 'a term -> bool
                val pred_closed : pred -> bool
                val freevars : pred -> var list
                val p_forall : var list -> pred -> pred
                val p_exists : var list -> pred -> pred
                val p_subst :
                  (var -> var option) -> var -> 'a term -> pred -> pred
                val e_subst :
                  (var -> var option) -> var -> 'a term -> 'b term -> 'b term
                val e_rename : (var * var) list -> 'a term -> 'a term
                val equal_terms : 'a term -> 'a term -> bool
                type alpha = F.alpha
                val empty_alpha : alpha
                val fold_alpha :
                  (var -> var -> '-> 'a) -> alpha -> '-> 'a
                val p_more_alpha_cv : alpha -> pred -> alpha * pred
                val p_alpha_cv : pred -> var list * pred
                val pp_var : Format.formatter -> var -> unit
                val pp_section : Format.formatter -> string -> unit
                val pp_term : Format.formatter -> 'a term -> unit
                val pp_pred : Format.formatter -> pred -> unit
                val pp_decl : Format.formatter -> decl -> unit
                val pp_goal : Format.formatter -> string -> pred -> unit
                val pp_vkind : Format.formatter -> Formula.kind -> unit
                val e_app0 : string -> 'a term
                val e_app1 : string -> 'a term -> 'b term
                val e_app2 : string -> 'a term -> 'b term -> 'c term
                val e_app3 :
                  string -> 'a term -> 'b term -> 'c term -> 'd term
                val e_app4 :
                  string ->
                  'a term -> 'b term -> 'c term -> 'd term -> 'e term
                val e_app5 :
                  string ->
                  'a term ->
                  'b term -> 'c term -> 'd term -> 'e term -> 'f term
                val p_app0 : string -> pred
                val p_app1 : string -> 'a term -> pred
                val p_app2 : string -> 'a term -> 'b term -> pred
                val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
                val p_app4 :
                  string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
                val p_app5 :
                  string ->
                  'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
                val dummy : unit -> pred
                val i_zero : integer
                val r_zero : real
                val i_one : integer
                val i_add : integer -> integer -> integer
                val i_mult : integer -> integer -> integer
                val i_sub : integer -> integer -> integer
                val guard : Ctypes.c_int -> integer -> pred
                val modulo : Ctypes.c_int -> integer -> integer
                val i_convert :
                  Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                type interval =
                  F.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'F.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                type havoc =
                  F.havoc =
                    Fresh of var
                  | Update of var * ((var * var) list -> abstract)
                val pp_interval : Format.formatter -> interval -> unit
                val set_range_index : array -> interval -> array
                val empty : set
                val singleton : abstract -> set
                val union : set -> set -> set
                val unions : set list -> set
                val inter : set -> set -> set
                val remove : set -> set -> set
                val set_of_list : abstract list -> set
                val add_set : set -> set -> set
                val mult_set : set -> set -> set
                val neg_set : set -> set
                val interval : interval -> set
                val acc_field : record -> Cil_types.fieldinfo -> abstract
                val upd_field :
                  record -> Cil_types.fieldinfo -> abstract -> record
                val acc_index : array -> integer -> abstract
                val upd_index : array -> integer -> abstract -> array
                module type Indexed =
                  sig
                    type t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
                module Dindex :
                  functor (I : Identifiable->
                    sig
                      type t = I.t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                module Findex :
                  sig
                    type t = Cil_types.fieldinfo
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
                module Xindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
                module Aindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
                module Tindex :
                  sig
                    type t = Cil_types.compinfo
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
                module LTindex :
                  sig
                    type t = Cil_types.logic_type
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
              end
            type st_loc = {
              base : Store_mem.Create.Model.F.integer;
              off : Store_mem.Create.Model.F.integer;
              obj : Ctypes.c_object;
            }
            val upd_base :
              Store_mem.Create.Model.st_loc ->
              Store_mem.Create.Model.F.integer ->
              Store_mem.Create.Model.st_loc
            val upd_off :
              Store_mem.Create.Model.st_loc ->
              Store_mem.Create.Model.F.integer ->
              Store_mem.Create.Model.st_loc
            val upd_obj :
              Store_mem.Create.Model.st_loc ->
              Ctypes.c_object -> Store_mem.Create.Model.st_loc
            type loc =
                Loc of Store_mem.Create.Model.st_loc
              | Addr of Store_mem.Create.Model.F.integer * Ctypes.c_object
            val addr :
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.integer
            val base :
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.integer
            val offset :
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.integer
            val object_of_loc : Store_mem.Create.Model.loc -> Ctypes.c_object
            val sizeof_loc :
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.integer
            val loc_of_term :
              Ctypes.c_object ->
              Store_mem.Create.Model.F.abstract -> Store_mem.Create.Model.loc
            val term_of_loc :
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.abstract
            val null : Store_mem.Create.Model.loc
            val is_null :
              Store_mem.Create.Model.loc -> 'Store_mem.Create.Model.F.term
            val lt_loc :
              Store_mem.Create.Model.loc ->
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.pred
            val le_loc :
              Store_mem.Create.Model.loc ->
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.pred
            val equal_loc :
              Store_mem.Create.Model.loc ->
              Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.pred
            val lt_loc_bool :
              Store_mem.Create.Model.loc ->
              Store_mem.Create.Model.loc -> 'Store_mem.Create.Model.F.term
            val le_loc_bool :
              Store_mem.Create.Model.loc ->
              Store_mem.Create.Model.loc -> 'Store_mem.Create.Model.F.term
            val equal_loc_bool :
              Store_mem.Create.Model.loc ->
              Store_mem.Create.Model.loc -> 'Store_mem.Create.Model.F.term
            val minus_loc :
              Store_mem.Create.Model.loc ->
              Store_mem.Create.Model.loc -> 'Store_mem.Create.Model.F.term
            val cast_loc_to_int :
              '->
              Store_mem.Create.Model.loc ->
              '-> Store_mem.Create.Model.F.integer
            val cast_int_to_loc :
              '->
              Store_mem.Create.Model.F.integer ->
              Cil_types.typ -> Store_mem.Create.Model.loc
            val pp_loc :
              Format.formatter -> Store_mem.Create.Model.loc -> unit
            val tau_of_loc : Formula.tau
          end
        module Globals :
          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 Data :
          sig
            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 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 = Store_mem.Create.m_memory
            val tau_of_mem : Formula.tau
            val forall_loc :
              Store_mem.Create.Model.F.pool ->
              Store_mem.Create.Model.F.var list * Store_mem.Create.Model.loc
            val load_rec :
              (Store_mem.Create.Data.m_of_mem F.term ->
               Ctypes.c_object -> loc -> value)
              Pervasives.ref
            val store_rec :
              (Store_mem.Create.Data.m_of_mem F.term ->
               Ctypes.c_object ->
               loc -> value -> Store_mem.Create.Data.m_of_mem F.term)
              Pervasives.ref
            val define_vinfo : Store_mem.Create.Globals.t -> unit
            val global : Store_mem.Create.Globals.t -> unit
            val cvar_of_var :
              Store_mem.Create.Globals.t -> Store_mem.Create.Model.loc
            val cvar :
              '-> Store_mem.Create.Globals.t -> Store_mem.Create.Model.loc
            val inner_loc : '-> 'b
            val lvar :
              '->
              Cil_types.logic_var ->
              Store_mem.Create.Model.F.var -> Store_mem.Create.Model.loc
            val offset :
              Store_mem.Create.Model.loc ->
              Ctypes.c_object ->
              Formula.m_integer Store_mem.Create.Model.F.term ->
              Store_mem.Create.Model.loc
            val shift :
              Store_mem.Create.Model.loc ->
              Ctypes.c_object ->
              Formula.m_integer Store_mem.Create.Model.F.term ->
              Store_mem.Create.Model.loc
            val index :
              Store_mem.Create.Model.loc ->
              Ctypes.c_object ->
              Formula.m_integer Store_mem.Create.Model.F.term ->
              Store_mem.Create.Model.loc
            val field :
              Store_mem.Create.Model.loc ->
              Cil_datatype.Fieldinfo.t -> Store_mem.Create.Model.loc
            val load_mem :
              Store_mem.Create.Data.m_of_mem F.term ->
              Ctypes.c_object -> loc -> value
            val store_mem :
              Store_mem.Create.Data.m_of_mem F.term ->
              Ctypes.c_object ->
              loc -> value -> Store_mem.Create.Data.m_of_mem F.term
            val mem : unit -> Store_mem.Create.mem
          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
        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 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_memory
        val tau_of_mem : Formula.tau
        val forall_loc : Model.F.pool -> Model.F.var list * Model.loc
        val load_rec :
          (m_of_mem F.term -> Ctypes.c_object -> loc -> value) ref
        val store_rec :
          (m_of_mem F.term ->
           Ctypes.c_object -> loc -> value -> m_of_mem F.term)
          ref
        val define_vinfo : Globals.t -> unit
        val global : Globals.t -> unit
        val cvar_of_var : Globals.t -> Model.loc
        val cvar : '-> Globals.t -> Model.loc
        val inner_loc : '-> 'b
        val lvar : '-> Cil_types.logic_var -> Model.F.var -> Model.loc
        val offset :
          Model.loc ->
          Ctypes.c_object -> Formula.m_integer Model.F.term -> Model.loc
        val shift :
          Model.loc ->
          Ctypes.c_object -> Formula.m_integer Model.F.term -> Model.loc
        val index :
          Model.loc ->
          Ctypes.c_object -> Formula.m_integer Model.F.term -> Model.loc
        val field : Model.loc -> Cil_datatype.Fieldinfo.t -> Model.loc
        val load_mem : m_of_mem F.term -> Ctypes.c_object -> loc -> value
        val store_mem :
          m_of_mem F.term ->
          Ctypes.c_object -> loc -> value -> m_of_mem F.term
        val mem : unit -> mem
        val startof : '-> '-> 'a
        val base_address :
          '-> Store_mem.Create.Model.loc -> Store_mem.Create.Model.loc
        val block_length :
          '->
          Store_mem.Create.Model.loc -> Store_mem.Create.Model.F.integer
        val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> '-> 'a
        val zrange :
          Store_mem.Create.Model.loc -> F.integer -> Store_mem.Create.dzone
        module SofData :
          sig
            type t = Cil_types.compinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        module DataofS :
          sig
            type t = Cil_types.compinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        val s_of_data : SofData.t -> 'Model.F.term -> 'Model.F.term
        val data_of_s : DataofS.t -> 'Model.F.term -> 'Model.F.term
        module Ax2SofData :
          sig
            type t = Cil_types.compinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        module Ax3IsSofData :
          sig
            type t = Cil_types.compinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        val coerce_comp : Store_mem.Create.SofData.t -> unit
        val s_of_data :
          Store_mem.Create.SofData.t ->
          'Store_mem.Create.Model.F.term ->
          'Store_mem.Create.Model.F.term
        val data_of_s :
          Store_mem.Create.SofData.t ->
          'Store_mem.Create.Model.F.term ->
          'Store_mem.Create.Model.F.term
        module AofData :
          sig
            type t = Ctypes.arrayinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        module DataofA :
          sig
            type t = Ctypes.arrayinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        val a_of_data : AofData.t -> 'Model.F.term -> 'Model.F.term
        val data_of_a : DataofA.t -> 'Model.F.term -> 'Model.F.term
        module Ax2AofData :
          sig
            type t = Ctypes.arrayinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        module Ax3IsAofData :
          sig
            type t = Ctypes.arrayinfo
            val define : t -> unit
            val get_definition : t -> Model.F.decl
            val on_definition : (t -> Model.F.decl -> unit) -> unit
          end
        val coerce_arr : Store_mem.Create.AofData.t -> unit
        val a_of_data :
          Store_mem.Create.AofData.t ->
          'Store_mem.Create.Model.F.term ->
          'Store_mem.Create.Model.F.term
        val data_of_a :
          Store_mem.Create.AofData.t ->
          'Store_mem.Create.Model.F.term ->
          'Store_mem.Create.Model.F.term
        val load_with :
          'F.term ->
          Store_mem.Create.Model.F.array ->
          Store_mem.Create.Model.loc -> 'F.term
        val load_mem :
          Store_mem.Create.Model.F.array ->
          Ctypes.c_object -> Store_mem.Create.Model.loc -> value
        val store_with :
          Store_mem.Create.Model.F.array ->
          Store_mem.Create.Model.loc ->
          'F.term -> 'F.term -> Store_mem.Create.Model.F.array
        val store_mem :
          Store_mem.Create.Model.F.array ->
          Ctypes.c_object ->
          Store_mem.Create.Model.loc ->
          value -> Store_mem.Create.Model.F.array
        val load :
          Store_mem.Create.mem ->
          Ctypes.c_object -> Store_mem.Create.Model.loc -> value
        val tau_of_dzone : Formula.tau
        type assignable =
            Xrange of Store_mem.Create.Model.F.integer *
              Store_mem.Create.Model.F.integer *
              Store_mem.Create.Model.F.integer
          | Arange of Store_mem.Create.Model.F.integer *
              Store_mem.Create.Model.F.integer *
              Store_mem.Create.Model.F.integer
          | Ablock of Store_mem.Create.Model.F.integer
        val addr_of_assignable : Store_mem.Create.assignable -> F.integer
        val zone_of_assignable :
          Store_mem.Create.assignable -> Store_mem.Create.dzone
        val assignable_loc :
          Ctypes.c_object ->
          Store_mem.Create.Model.loc -> Store_mem.Create.assignable
        val assignable_range :
          Store_mem.Create.mem ->
          Ctypes.c_object ->
          Store_mem.Create.Model.loc ->
          Store_mem.Create.Model.F.interval -> Store_mem.Create.assignable
        val assignable :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned ->
          Store_mem.Create.assignable
        val dzone_assigned :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned ->
          Store_mem.Create.dzone
        val dzone_subset :
          Store_mem.Create.dzone -> Store_mem.Create.dzone -> F.pred
        val dzone_union :
          Store_mem.Create.dzone ->
          Store_mem.Create.dzone -> Store_mem.Create.dzone
        val dzone_empty : unit -> Store_mem.Create.dzone
        val effect_supported : bool
        val assignable_sizeof :
          'Store_mem.Create.Model.F.assigned -> F.integer
        val valid :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned ->
          F.pred
        val get_zrange_opt :
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned ->
          (Store_mem.Create.Model.loc * F.integer) option
        val separated :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned ->
          Store_mem.Create.Model.F.pred
        val update :
          at:Store_mem.Create.mem ->
          here:Store_mem.Create.mem -> L.F.pred -> L.F.pred
        val quantify : Store_mem.Create.mem -> L.F.pred -> L.F.pred
        val subst_lval :
          Store_mem.Create.mem ->
          Ctypes.c_object ->
          Store_mem.Create.Model.loc -> value -> L.F.pred -> L.F.pred
        val alloc_vars :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.F.Xindex.t list -> L.F.pred -> L.F.pred
        val free_vars :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.F.Xindex.t list -> L.F.pred -> L.F.pred
        val fresh_vars :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.F.Xindex.t list ->
          Store_mem.Create.Model.F.pred -> Store_mem.Create.Model.F.pred
        val notexists_vars :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.F.Xindex.t list ->
          Store_mem.Create.Model.F.pred -> Store_mem.Create.Model.F.pred
        val global_scope :
          Store_mem.Create.mem -> L.F.pred -> Store_mem.Create.Model.F.pred
        val filter_scope :
          Store_mem.Create.Model.F.pred ->
          Store_mem.Create.Model.F.Xindex.t list ->
          Store_mem.Create.Model.F.Xindex.t list
        val local_scope :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.F.Xindex.t list ->
          Mcfg.scope ->
          Store_mem.Create.Model.F.pred -> Store_mem.Create.Model.F.pred
        val subst_havoc :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned ->
          Store_mem.Create.Model.F.havoc list
        val region :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned list ->
          Store_mem.Create.dzone
        val assigns_goal :
          Store_mem.Create.mem ->
          Store_mem.Create.Model.loc Store_mem.Create.Model.F.assigned list ->
          Store_mem.Create.mem -> F.pred
        val assigns_supported : bool
        type closure = Mem | Alloc
        val pp_closure : Format.formatter -> Store_mem.Create.closure -> unit
        val userdef_mem_signature :
          Store_mem.Create.mem -> (F.var * Store_mem.Create.closure) list
        val userdef_mem_apply :
          Store_mem.Create.mem ->
          Store_mem.Create.closure -> Store_mem.Create.Model.F.abstract
        type formal = unit
        val pp_formal : Format.formatter -> '-> unit
        val userdef_is_ref_param : Cil_types.logic_var -> bool
        val userdef_ref_signature :
          Store_mem.Create.mem ->
          (Store_mem.Create.Model.F.var * Cil_types.logic_var *
           Store_mem.Create.formal)
          list
        val userdef_ref_apply :
          Store_mem.Create.mem ->
          Store_mem.Create.formal -> Store_mem.Create.Model.loc -> value
        val userdef_ref_has_cvar : Cil_types.logic_var -> bool
      end