functor (Crit : Criteria->
  functor (M : Mwp.S->
    sig
      val make_array : Cil_types.typ -> Cil_types.typ
      val array_of : Cil_types.typ -> Cil_types.typ
      val pointed_of_arity : int -> Cil_types.typ -> Cil_types.typ
      val brackets_and_stars_typ : Cil_types.typ -> int * int
      val brackets_and_stars_lv_typ : Cil_types.logic_type -> int * int
      module Lookup :
        sig
          module F :
            sig
              type var = M.F.var
              type 'a term = 'M.F.term
              type pred = M.F.pred
              type abstract = Formula.m_abstract term
              type integer = Formula.m_integer term
              type real = Formula.m_real term
              type boolean = Formula.m_boolean term
              type record = Formula.m_record term
              type urecord = Formula.m_array term
              type array = Formula.m_array term
              type set = Formula.m_set term
              type name = Formula.m_integer term
              type decl = (var, abstract, pred) Formula.declaration
              val e_int : int -> integer
              val e_call : string -> abstract list -> abstract
              val p_call : string -> abstract list -> pred
              val wrap : 'a term -> abstract
              val unwrap : abstract -> 'a term
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : decl -> unit
              val has_declaration : string -> bool
              val iter_all : (string -> unit) -> (decl -> unit) -> unit
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare :
                    t -> string -> (var, abstract, pred) Formula.item
                end
              module DRegister :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = M.F.Varinfo.H.key
                      type 'a t = 'M.F.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = M.F.Varaddr.H.key
                      type 'a t = 'M.F.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = M.F.Fieldinfo.H.key
                      type 'a t = 'M.F.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = M.F.Compinfo.H.key
                      type 'a t = 'M.F.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = M.F.Arrayinfo.H.key
                      type 'a t = 'M.F.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = M.F.Logicvar.H.key
                      type 'a t = 'M.F.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module LTypeinfo :
                sig
                  type t = Cil_types.logic_type
                  module H :
                    sig
                      type key = M.F.LTypeinfo.H.key
                      type 'a t = 'M.F.LTypeinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Cobject :
                sig
                  type t = Ctypes.c_object
                  module H :
                    sig
                      type key = M.F.Cobject.H.key
                      type 'a t = 'M.F.Cobject.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module ArrayDim :
                sig
                  type t = Ctypes.c_object * int
                  module H :
                    sig
                      type key = M.F.ArrayDim.H.key
                      type 'a t = 'M.F.ArrayDim.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              val adt_decl : Cil_types.logic_type_info -> string
              val pp_tau : Format.formatter -> Formula.tau -> unit
              val e_true : boolean
              val e_false : boolean
              val e_float : float -> real
              val e_icst : string -> integer
              val e_rcst : string -> real
              val e_int64 : int64 -> integer
              val e_ineg : integer -> integer
              val e_rneg : real -> real
              val e_iop : Formula.int_op -> integer -> integer -> integer
              val e_rop : Formula.real_op -> real -> real -> real
              val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
              val e_rcmp : Formula.cmp_op -> real -> real -> boolean
              val p_icmp : Formula.cmp_op -> integer -> integer -> pred
              val p_rcmp : Formula.cmp_op -> real -> real -> pred
              val e_bnot : integer -> integer
              val e_band : integer -> integer -> integer
              val e_bor : integer -> integer -> integer
              val e_bxor : integer -> integer -> integer
              val e_lshift : integer -> integer -> integer
              val e_rshift : integer -> integer -> integer
              val integer_of_real : real -> integer
              val real_of_integer : integer -> real
              val e_bool : boolean -> integer
              val e_not : boolean -> boolean
              val e_and : boolean -> boolean -> boolean
              val e_or : boolean -> boolean -> boolean
              val e_cond : boolean -> 'a term -> 'a term -> 'a term
              val p_cond : boolean -> pred -> pred -> pred
              val e_getfield : Cil_types.fieldinfo -> record -> abstract
              val e_setfield :
                Cil_types.fieldinfo -> record -> abstract -> record
              val e_access : array -> integer -> abstract
              val e_update : array -> integer -> abstract -> array
              val p_true : pred
              val p_false : pred
              val p_bool : boolean -> pred
              val p_and : pred -> pred -> pred
              val p_or : pred -> pred -> pred
              val p_xor : pred -> pred -> pred
              val p_not : pred -> pred
              val p_implies : pred -> pred -> pred
              val p_iff : pred -> pred -> pred
              val p_eq : 'a term -> 'a term -> pred
              val p_neq : 'a term -> 'a term -> pred
              val p_conj : pred list -> pred
              val p_disj : pred list -> pred
              val p_named : string -> pred -> pred
              val is_true : pred -> bool
              val is_false : pred -> bool
              val huge_term : int -> 'a term -> bool
              val huge_pred : int -> pred -> bool
              type pool = M.F.pool
              val pool : unit -> pool
              val p_fresh : pool -> string -> Formula.kind -> var
              val p_freshen : pool -> var -> var
              val var : var -> 'a term
              val eq_var : var -> var -> bool
              val name_of_var : var -> string
              val basename_of_var : var -> string
              val tau_of_var : var -> Formula.tau
              val kind_of_var : var -> Formula.kind
              val term_has_var : var list -> 'a term -> bool
              val pred_has_var : var list -> pred -> bool
              val term_calls : string -> 'a term -> bool
              val pred_calls : string -> pred -> bool
              val term_closed : 'a term -> bool
              val pred_closed : pred -> bool
              val freevars : pred -> var list
              val p_forall : var list -> pred -> pred
              val p_exists : var list -> pred -> pred
              val p_subst :
                (var -> var option) -> var -> 'a term -> pred -> pred
              val e_subst :
                (var -> var option) -> var -> 'a term -> 'b term -> 'b term
              val e_rename : (var * var) list -> 'a term -> 'a term
              val equal_terms : 'a term -> 'a term -> bool
              type alpha = M.F.alpha
              val empty_alpha : alpha
              val fold_alpha : (var -> var -> '-> 'a) -> alpha -> '-> 'a
              val p_more_alpha_cv : alpha -> pred -> alpha * pred
              val p_alpha_cv : pred -> var list * pred
              val pp_var : Format.formatter -> var -> unit
              val pp_section : Format.formatter -> string -> unit
              val pp_term : Format.formatter -> 'a term -> unit
              val pp_pred : Format.formatter -> pred -> unit
              val pp_decl : Format.formatter -> decl -> unit
              val pp_goal : Format.formatter -> string -> pred -> unit
              val pp_vkind : Format.formatter -> Formula.kind -> unit
              val e_app0 : string -> 'a term
              val e_app1 : string -> 'a term -> 'b term
              val e_app2 : string -> 'a term -> 'b term -> 'c term
              val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
              val e_app4 :
                string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
              val e_app5 :
                string ->
                'a term ->
                'b term -> 'c term -> 'd term -> 'e term -> 'f term
              val p_app0 : string -> pred
              val p_app1 : string -> 'a term -> pred
              val p_app2 : string -> 'a term -> 'b term -> pred
              val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
              val p_app4 :
                string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
              val p_app5 :
                string ->
                'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
              val dummy : unit -> pred
              val i_zero : integer
              val r_zero : real
              val i_one : integer
              val i_add : integer -> integer -> integer
              val i_mult : integer -> integer -> integer
              val i_sub : integer -> integer -> integer
              val guard : Ctypes.c_int -> integer -> pred
              val modulo : Ctypes.c_int -> integer -> integer
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              type interval =
                M.F.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'M.F.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              type havoc =
                M.F.havoc =
                  Fresh of var
                | Update of var * ((var * var) list -> abstract)
              val pp_interval : Format.formatter -> interval -> unit
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module LTindex :
                sig
                  type t = Cil_types.logic_type
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
            end
          type poffset =
              Ofield of Cil_types.fieldinfo
            | Oindex of Funvar_mem.Create.Lookup.F.integer * Ctypes.c_object
          type root = Cvar of Cil_types.varinfo | Lvar of Cil_types.logic_var
          type path = {
            p_root : Funvar_mem.Create.Lookup.root;
            p_mem : M.mem;
            p_arity : int;
            p_off : Funvar_mem.Create.Lookup.poffset list;
            p_type : Ctypes.c_object option;
            p_cvar : Funvar_mem.Create.Lookup.F.var option;
          }
          val pp_root :
            Format.formatter -> Funvar_mem.Create.Lookup.root -> unit
          val pp_path :
            Format.formatter -> Funvar_mem.Create.Lookup.path -> unit
          val object_of_root :
            Funvar_mem.Create.Lookup.root -> Ctypes.c_object option
          val object_array_of_root :
            Funvar_mem.Create.Lookup.root -> Ctypes.c_object option
          val object_of_n_pointed : int -> Ctypes.c_object -> Ctypes.c_object
          val object_of_pointed_opt :
            Ctypes.c_object option -> Ctypes.c_object option
          val object_of_n_pointed_opt :
            int -> Ctypes.c_object option -> Ctypes.c_object option
          val pointed_of_path :
            Funvar_mem.Create.Lookup.path -> Funvar_mem.Create.Lookup.path
          val pointed_of_n_path :
            int ->
            Funvar_mem.Create.Lookup.path -> Funvar_mem.Create.Lookup.path
          val sizeof_poffset :
            Funvar_mem.Create.Lookup.poffset ->
            Funvar_mem.Create.Lookup.F.integer
          val sizeof_path :
            Funvar_mem.Create.Lookup.poffset list ->
            Funvar_mem.Create.Lookup.F.integer
          val access_poffset :
            Funvar_mem.Create.Lookup.F.abstract ->
            Funvar_mem.Create.Lookup.poffset ->
            Funvar_mem.Create.Lookup.F.abstract
          val access :
            Funvar_mem.Create.Lookup.F.abstract ->
            Funvar_mem.Create.Lookup.poffset list ->
            Funvar_mem.Create.Lookup.F.abstract
          val mcvar :
            M.mem ->
            Funvar_mem.Create.Lookup.root ->
            Funvar_mem.Create.Lookup.F.var option -> M.loc
          val mloc_of_path : Funvar_mem.Create.Lookup.path -> M.loc
        end
      module Model :
        sig
          module F :
            sig
              type var = M.F.var
              type 'a term = 'M.F.term
              type pred = M.F.pred
              type abstract = Formula.m_abstract term
              type integer = Formula.m_integer term
              type real = Formula.m_real term
              type boolean = Formula.m_boolean term
              type record = Formula.m_record term
              type urecord = Formula.m_array term
              type array = Formula.m_array term
              type set = Formula.m_set term
              type name = Formula.m_integer term
              type decl = (var, abstract, pred) Formula.declaration
              val e_int : int -> integer
              val e_call : string -> abstract list -> abstract
              val p_call : string -> abstract list -> pred
              val wrap : 'a term -> abstract
              val unwrap : abstract -> 'a term
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : decl -> unit
              val has_declaration : string -> bool
              val iter_all : (string -> unit) -> (decl -> unit) -> unit
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare :
                    t -> string -> (var, abstract, pred) Formula.item
                end
              module DRegister :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = M.F.Varinfo.H.key
                      type 'a t = 'M.F.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = M.F.Varaddr.H.key
                      type 'a t = 'M.F.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = M.F.Fieldinfo.H.key
                      type 'a t = 'M.F.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = M.F.Compinfo.H.key
                      type 'a t = 'M.F.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = M.F.Arrayinfo.H.key
                      type 'a t = 'M.F.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = M.F.Logicvar.H.key
                      type 'a t = 'M.F.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module LTypeinfo :
                sig
                  type t = Cil_types.logic_type
                  module H :
                    sig
                      type key = M.F.LTypeinfo.H.key
                      type 'a t = 'M.F.LTypeinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Cobject :
                sig
                  type t = Ctypes.c_object
                  module H :
                    sig
                      type key = M.F.Cobject.H.key
                      type 'a t = 'M.F.Cobject.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module ArrayDim :
                sig
                  type t = Ctypes.c_object * int
                  module H :
                    sig
                      type key = M.F.ArrayDim.H.key
                      type 'a t = 'M.F.ArrayDim.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              val adt_decl : Cil_types.logic_type_info -> string
              val pp_tau : Format.formatter -> Formula.tau -> unit
              val e_true : boolean
              val e_false : boolean
              val e_float : float -> real
              val e_icst : string -> integer
              val e_rcst : string -> real
              val e_int64 : int64 -> integer
              val e_ineg : integer -> integer
              val e_rneg : real -> real
              val e_iop : Formula.int_op -> integer -> integer -> integer
              val e_rop : Formula.real_op -> real -> real -> real
              val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
              val e_rcmp : Formula.cmp_op -> real -> real -> boolean
              val p_icmp : Formula.cmp_op -> integer -> integer -> pred
              val p_rcmp : Formula.cmp_op -> real -> real -> pred
              val e_bnot : integer -> integer
              val e_band : integer -> integer -> integer
              val e_bor : integer -> integer -> integer
              val e_bxor : integer -> integer -> integer
              val e_lshift : integer -> integer -> integer
              val e_rshift : integer -> integer -> integer
              val integer_of_real : real -> integer
              val real_of_integer : integer -> real
              val e_bool : boolean -> integer
              val e_not : boolean -> boolean
              val e_and : boolean -> boolean -> boolean
              val e_or : boolean -> boolean -> boolean
              val e_cond : boolean -> 'a term -> 'a term -> 'a term
              val p_cond : boolean -> pred -> pred -> pred
              val e_getfield : Cil_types.fieldinfo -> record -> abstract
              val e_setfield :
                Cil_types.fieldinfo -> record -> abstract -> record
              val e_access : array -> integer -> abstract
              val e_update : array -> integer -> abstract -> array
              val p_true : pred
              val p_false : pred
              val p_bool : boolean -> pred
              val p_and : pred -> pred -> pred
              val p_or : pred -> pred -> pred
              val p_xor : pred -> pred -> pred
              val p_not : pred -> pred
              val p_implies : pred -> pred -> pred
              val p_iff : pred -> pred -> pred
              val p_eq : 'a term -> 'a term -> pred
              val p_neq : 'a term -> 'a term -> pred
              val p_conj : pred list -> pred
              val p_disj : pred list -> pred
              val p_named : string -> pred -> pred
              val is_true : pred -> bool
              val is_false : pred -> bool
              val huge_term : int -> 'a term -> bool
              val huge_pred : int -> pred -> bool
              type pool = M.F.pool
              val pool : unit -> pool
              val p_fresh : pool -> string -> Formula.kind -> var
              val p_freshen : pool -> var -> var
              val var : var -> 'a term
              val eq_var : var -> var -> bool
              val name_of_var : var -> string
              val basename_of_var : var -> string
              val tau_of_var : var -> Formula.tau
              val kind_of_var : var -> Formula.kind
              val term_has_var : var list -> 'a term -> bool
              val pred_has_var : var list -> pred -> bool
              val term_calls : string -> 'a term -> bool
              val pred_calls : string -> pred -> bool
              val term_closed : 'a term -> bool
              val pred_closed : pred -> bool
              val freevars : pred -> var list
              val p_forall : var list -> pred -> pred
              val p_exists : var list -> pred -> pred
              val p_subst :
                (var -> var option) -> var -> 'a term -> pred -> pred
              val e_subst :
                (var -> var option) -> var -> 'a term -> 'b term -> 'b term
              val e_rename : (var * var) list -> 'a term -> 'a term
              val equal_terms : 'a term -> 'a term -> bool
              type alpha = M.F.alpha
              val empty_alpha : alpha
              val fold_alpha : (var -> var -> '-> 'a) -> alpha -> '-> 'a
              val p_more_alpha_cv : alpha -> pred -> alpha * pred
              val p_alpha_cv : pred -> var list * pred
              val pp_var : Format.formatter -> var -> unit
              val pp_section : Format.formatter -> string -> unit
              val pp_term : Format.formatter -> 'a term -> unit
              val pp_pred : Format.formatter -> pred -> unit
              val pp_decl : Format.formatter -> decl -> unit
              val pp_goal : Format.formatter -> string -> pred -> unit
              val pp_vkind : Format.formatter -> Formula.kind -> unit
              val e_app0 : string -> 'a term
              val e_app1 : string -> 'a term -> 'b term
              val e_app2 : string -> 'a term -> 'b term -> 'c term
              val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
              val e_app4 :
                string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
              val e_app5 :
                string ->
                'a term ->
                'b term -> 'c term -> 'd term -> 'e term -> 'f term
              val p_app0 : string -> pred
              val p_app1 : string -> 'a term -> pred
              val p_app2 : string -> 'a term -> 'b term -> pred
              val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
              val p_app4 :
                string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
              val p_app5 :
                string ->
                'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
              val dummy : unit -> pred
              val i_zero : integer
              val r_zero : real
              val i_one : integer
              val i_add : integer -> integer -> integer
              val i_mult : integer -> integer -> integer
              val i_sub : integer -> integer -> integer
              val guard : Ctypes.c_int -> integer -> pred
              val modulo : Ctypes.c_int -> integer -> integer
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              type interval =
                M.F.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'M.F.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              type havoc =
                M.F.havoc =
                  Fresh of var
                | Update of var * ((var * var) list -> abstract)
              val pp_interval : Format.formatter -> interval -> unit
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module LTindex :
                sig
                  type t = Cil_types.logic_type
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
            end
          module A :
            sig
              module F :
                sig
                  type var = M.F.var
                  type 'a term = 'M.F.term
                  type pred = M.F.pred
                  type abstract = Formula.m_abstract term
                  type integer = Formula.m_integer term
                  type real = Formula.m_real term
                  type boolean = Formula.m_boolean term
                  type record = Formula.m_record term
                  type urecord = Formula.m_array term
                  type array = Formula.m_array term
                  type set = Formula.m_set term
                  type name = Formula.m_integer term
                  type decl = (var, abstract, pred) Formula.declaration
                  val e_int : int -> integer
                  val e_call : string -> abstract list -> abstract
                  val p_call : string -> abstract list -> pred
                  val wrap : 'a term -> abstract
                  val unwrap : abstract -> 'a term
                  val clear : unit -> unit
                  val on_clear : (unit -> unit) -> unit
                  val fresh_name : string -> string -> string
                  val add_declaration : decl -> unit
                  val has_declaration : string -> bool
                  val iter_all : (string -> unit) -> (decl -> unit) -> unit
                  module type Identifiable =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module type Registry =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                    end
                  module type Declarator =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                      val clear : unit -> unit
                      val section : Formula.section
                      val declare :
                        t -> string -> (var, abstract, pred) Formula.item
                    end
                  module DRegister :
                    functor (D : Declarator->
                      sig
                        type t = D.t
                        val define : t -> unit
                        val get_definition : t -> decl
                        val on_definition : (t -> decl -> unit) -> unit
                      end
                  module Varinfo :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = M.F.Varinfo.H.key
                          type 'a t = 'M.F.Varinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Varaddr :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = M.F.Varaddr.H.key
                          type 'a t = 'M.F.Varaddr.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Fieldinfo :
                    sig
                      type t = Cil_types.fieldinfo
                      module H :
                        sig
                          type key = M.F.Fieldinfo.H.key
                          type 'a t = 'M.F.Fieldinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Compinfo :
                    sig
                      type t = Cil_types.compinfo
                      module H :
                        sig
                          type key = M.F.Compinfo.H.key
                          type 'a t = 'M.F.Compinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Arrayinfo :
                    sig
                      type t = Ctypes.arrayinfo
                      module H :
                        sig
                          type key = M.F.Arrayinfo.H.key
                          type 'a t = 'M.F.Arrayinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Logicvar :
                    sig
                      type t = Cil_types.logic_var
                      module H :
                        sig
                          type key = M.F.Logicvar.H.key
                          type 'a t = 'M.F.Logicvar.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module LTypeinfo :
                    sig
                      type t = Cil_types.logic_type
                      module H :
                        sig
                          type key = M.F.LTypeinfo.H.key
                          type 'a t = 'M.F.LTypeinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Cobject :
                    sig
                      type t = Ctypes.c_object
                      module H :
                        sig
                          type key = M.F.Cobject.H.key
                          type 'a t = 'M.F.Cobject.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module ArrayDim :
                    sig
                      type t = Ctypes.c_object * int
                      module H :
                        sig
                          type key = M.F.ArrayDim.H.key
                          type 'a t = 'M.F.ArrayDim.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  val adt_decl : Cil_types.logic_type_info -> string
                  val pp_tau : Format.formatter -> Formula.tau -> unit
                  val e_true : boolean
                  val e_false : boolean
                  val e_float : float -> real
                  val e_icst : string -> integer
                  val e_rcst : string -> real
                  val e_int64 : int64 -> integer
                  val e_ineg : integer -> integer
                  val e_rneg : real -> real
                  val e_iop : Formula.int_op -> integer -> integer -> integer
                  val e_rop : Formula.real_op -> real -> real -> real
                  val e_icmp :
                    Formula.cmp_op -> integer -> integer -> boolean
                  val e_rcmp : Formula.cmp_op -> real -> real -> boolean
                  val p_icmp : Formula.cmp_op -> integer -> integer -> pred
                  val p_rcmp : Formula.cmp_op -> real -> real -> pred
                  val e_bnot : integer -> integer
                  val e_band : integer -> integer -> integer
                  val e_bor : integer -> integer -> integer
                  val e_bxor : integer -> integer -> integer
                  val e_lshift : integer -> integer -> integer
                  val e_rshift : integer -> integer -> integer
                  val integer_of_real : real -> integer
                  val real_of_integer : integer -> real
                  val e_bool : boolean -> integer
                  val e_not : boolean -> boolean
                  val e_and : boolean -> boolean -> boolean
                  val e_or : boolean -> boolean -> boolean
                  val e_cond : boolean -> 'a term -> 'a term -> 'a term
                  val p_cond : boolean -> pred -> pred -> pred
                  val e_getfield : Cil_types.fieldinfo -> record -> abstract
                  val e_setfield :
                    Cil_types.fieldinfo -> record -> abstract -> record
                  val e_access : array -> integer -> abstract
                  val e_update : array -> integer -> abstract -> array
                  val p_true : pred
                  val p_false : pred
                  val p_bool : boolean -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type pool = M.F.pool
                  val pool : unit -> pool
                  val p_fresh : pool -> string -> Formula.kind -> var
                  val p_freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val basename_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_calls : string -> 'a term -> bool
                  val pred_calls : string -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val freevars : pred -> var list
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = M.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_section : Format.formatter -> string -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl : Format.formatter -> decl -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                  val pp_vkind : Format.formatter -> Formula.kind -> unit
                  val e_app0 : string -> 'a term
                  val e_app1 : string -> 'a term -> 'b term
                  val e_app2 : string -> 'a term -> 'b term -> 'c term
                  val e_app3 :
                    string -> 'a term -> 'b term -> 'c term -> 'd term
                  val e_app4 :
                    string ->
                    'a term -> 'b term -> 'c term -> 'd term -> 'e term
                  val e_app5 :
                    string ->
                    'a term ->
                    'b term -> 'c term -> 'd term -> 'e term -> 'f term
                  val p_app0 : string -> pred
                  val p_app1 : string -> 'a term -> pred
                  val p_app2 : string -> 'a term -> 'b term -> pred
                  val p_app3 :
                    string -> 'a term -> 'b term -> 'c term -> pred
                  val p_app4 :
                    string ->
                    'a term -> 'b term -> 'c term -> 'd term -> pred
                  val p_app5 :
                    string ->
                    'a term ->
                    'b term -> 'c term -> 'd term -> 'e term -> pred
                  val dummy : unit -> pred
                  val i_zero : integer
                  val r_zero : real
                  val i_one : integer
                  val i_add : integer -> integer -> integer
                  val i_mult : integer -> integer -> integer
                  val i_sub : integer -> integer -> integer
                  val guard : Ctypes.c_int -> integer -> pred
                  val modulo : Ctypes.c_int -> integer -> integer
                  val i_convert :
                    Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                  type interval =
                    M.F.interval = {
                    inf : integer option;
                    sup : integer option;
                  }
                  type 'a assigned =
                    'M.F.assigned =
                      Aloc of Ctypes.c_object * 'a
                    | Arange of Ctypes.c_object * 'a * interval
                  type havoc =
                    M.F.havoc =
                      Fresh of var
                    | Update of var * ((var * var) list -> abstract)
                  val pp_interval : Format.formatter -> interval -> unit
                  val set_range_index : array -> interval -> array
                  val empty : set
                  val singleton : abstract -> set
                  val union : set -> set -> set
                  val unions : set list -> set
                  val inter : set -> set -> set
                  val remove : set -> set -> set
                  val set_of_list : abstract list -> set
                  val add_set : set -> set -> set
                  val mult_set : set -> set -> set
                  val neg_set : set -> set
                  val interval : interval -> set
                  val acc_field : record -> Cil_types.fieldinfo -> abstract
                  val upd_field :
                    record -> Cil_types.fieldinfo -> abstract -> record
                  val acc_index : array -> integer -> abstract
                  val upd_index : array -> integer -> abstract -> array
                  module type Indexed =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Dindex :
                    functor (I : Identifiable->
                      sig
                        type t = I.t
                        val define : t -> unit
                        val get_definition : t -> decl
                        val on_definition : (t -> decl -> unit) -> unit
                        val get_ind : t -> integer
                        val has_ind : t -> pred -> bool
                      end
                  module Findex :
                    sig
                      type t = Cil_types.fieldinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Xindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Aindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Tindex :
                    sig
                      type t = Cil_types.compinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module LTindex :
                    sig
                      type t = Cil_types.logic_type
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                end
              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 = M.F.var
                  type 'a term = 'M.F.term
                  type pred = M.F.pred
                  type abstract = Formula.m_abstract term
                  type integer = Formula.m_integer term
                  type real = Formula.m_real term
                  type boolean = Formula.m_boolean term
                  type record = Formula.m_record term
                  type urecord = Formula.m_array term
                  type array = Formula.m_array term
                  type set = Formula.m_set term
                  type name = Formula.m_integer term
                  type decl = (var, abstract, pred) Formula.declaration
                  val e_int : int -> integer
                  val e_call : string -> abstract list -> abstract
                  val p_call : string -> abstract list -> pred
                  val wrap : 'a term -> abstract
                  val unwrap : abstract -> 'a term
                  val clear : unit -> unit
                  val on_clear : (unit -> unit) -> unit
                  val fresh_name : string -> string -> string
                  val add_declaration : decl -> unit
                  val has_declaration : string -> bool
                  val iter_all : (string -> unit) -> (decl -> unit) -> unit
                  module type Identifiable =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module type Registry =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                    end
                  module type Declarator =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                      val clear : unit -> unit
                      val section : Formula.section
                      val declare :
                        t -> string -> (var, abstract, pred) Formula.item
                    end
                  module DRegister :
                    functor (D : Declarator->
                      sig
                        type t = D.t
                        val define : t -> unit
                        val get_definition : t -> decl
                        val on_definition : (t -> decl -> unit) -> unit
                      end
                  module Varinfo :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = M.F.Varinfo.H.key
                          type 'a t = 'M.F.Varinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Varaddr :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = M.F.Varaddr.H.key
                          type 'a t = 'M.F.Varaddr.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Fieldinfo :
                    sig
                      type t = Cil_types.fieldinfo
                      module H :
                        sig
                          type key = M.F.Fieldinfo.H.key
                          type 'a t = 'M.F.Fieldinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Compinfo :
                    sig
                      type t = Cil_types.compinfo
                      module H :
                        sig
                          type key = M.F.Compinfo.H.key
                          type 'a t = 'M.F.Compinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Arrayinfo :
                    sig
                      type t = Ctypes.arrayinfo
                      module H :
                        sig
                          type key = M.F.Arrayinfo.H.key
                          type 'a t = 'M.F.Arrayinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Logicvar :
                    sig
                      type t = Cil_types.logic_var
                      module H :
                        sig
                          type key = M.F.Logicvar.H.key
                          type 'a t = 'M.F.Logicvar.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module LTypeinfo :
                    sig
                      type t = Cil_types.logic_type
                      module H :
                        sig
                          type key = M.F.LTypeinfo.H.key
                          type 'a t = 'M.F.LTypeinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Cobject :
                    sig
                      type t = Ctypes.c_object
                      module H :
                        sig
                          type key = M.F.Cobject.H.key
                          type 'a t = 'M.F.Cobject.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module ArrayDim :
                    sig
                      type t = Ctypes.c_object * int
                      module H :
                        sig
                          type key = M.F.ArrayDim.H.key
                          type 'a t = 'M.F.ArrayDim.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  val adt_decl : Cil_types.logic_type_info -> string
                  val pp_tau : Format.formatter -> Formula.tau -> unit
                  val e_true : boolean
                  val e_false : boolean
                  val e_float : float -> real
                  val e_icst : string -> integer
                  val e_rcst : string -> real
                  val e_int64 : int64 -> integer
                  val e_ineg : integer -> integer
                  val e_rneg : real -> real
                  val e_iop : Formula.int_op -> integer -> integer -> integer
                  val e_rop : Formula.real_op -> real -> real -> real
                  val e_icmp :
                    Formula.cmp_op -> integer -> integer -> boolean
                  val e_rcmp : Formula.cmp_op -> real -> real -> boolean
                  val p_icmp : Formula.cmp_op -> integer -> integer -> pred
                  val p_rcmp : Formula.cmp_op -> real -> real -> pred
                  val e_bnot : integer -> integer
                  val e_band : integer -> integer -> integer
                  val e_bor : integer -> integer -> integer
                  val e_bxor : integer -> integer -> integer
                  val e_lshift : integer -> integer -> integer
                  val e_rshift : integer -> integer -> integer
                  val integer_of_real : real -> integer
                  val real_of_integer : integer -> real
                  val e_bool : boolean -> integer
                  val e_not : boolean -> boolean
                  val e_and : boolean -> boolean -> boolean
                  val e_or : boolean -> boolean -> boolean
                  val e_cond : boolean -> 'a term -> 'a term -> 'a term
                  val p_cond : boolean -> pred -> pred -> pred
                  val e_getfield : Cil_types.fieldinfo -> record -> abstract
                  val e_setfield :
                    Cil_types.fieldinfo -> record -> abstract -> record
                  val e_access : array -> integer -> abstract
                  val e_update : array -> integer -> abstract -> array
                  val p_true : pred
                  val p_false : pred
                  val p_bool : boolean -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type pool = M.F.pool
                  val pool : unit -> pool
                  val p_fresh : pool -> string -> Formula.kind -> var
                  val p_freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val basename_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_calls : string -> 'a term -> bool
                  val pred_calls : string -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val freevars : pred -> var list
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = M.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_section : Format.formatter -> string -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl : Format.formatter -> decl -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                  val pp_vkind : Format.formatter -> Formula.kind -> unit
                  val e_app0 : string -> 'a term
                  val e_app1 : string -> 'a term -> 'b term
                  val e_app2 : string -> 'a term -> 'b term -> 'c term
                  val e_app3 :
                    string -> 'a term -> 'b term -> 'c term -> 'd term
                  val e_app4 :
                    string ->
                    'a term -> 'b term -> 'c term -> 'd term -> 'e term
                  val e_app5 :
                    string ->
                    'a term ->
                    'b term -> 'c term -> 'd term -> 'e term -> 'f term
                  val p_app0 : string -> pred
                  val p_app1 : string -> 'a term -> pred
                  val p_app2 : string -> 'a term -> 'b term -> pred
                  val p_app3 :
                    string -> 'a term -> 'b term -> 'c term -> pred
                  val p_app4 :
                    string ->
                    'a term -> 'b term -> 'c term -> 'd term -> pred
                  val p_app5 :
                    string ->
                    'a term ->
                    'b term -> 'c term -> 'd term -> 'e term -> pred
                  val dummy : unit -> pred
                  val i_zero : integer
                  val r_zero : real
                  val i_one : integer
                  val i_add : integer -> integer -> integer
                  val i_mult : integer -> integer -> integer
                  val i_sub : integer -> integer -> integer
                  val guard : Ctypes.c_int -> integer -> pred
                  val modulo : Ctypes.c_int -> integer -> integer
                  val i_convert :
                    Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                  type interval =
                    M.F.interval = {
                    inf : integer option;
                    sup : integer option;
                  }
                  type 'a assigned =
                    'M.F.assigned =
                      Aloc of Ctypes.c_object * 'a
                    | Arange of Ctypes.c_object * 'a * interval
                  type havoc =
                    M.F.havoc =
                      Fresh of var
                    | Update of var * ((var * var) list -> abstract)
                  val pp_interval : Format.formatter -> interval -> unit
                  val set_range_index : array -> interval -> array
                  val empty : set
                  val singleton : abstract -> set
                  val union : set -> set -> set
                  val unions : set list -> set
                  val inter : set -> set -> set
                  val remove : set -> set -> set
                  val set_of_list : abstract list -> set
                  val add_set : set -> set -> set
                  val mult_set : set -> set -> set
                  val neg_set : set -> set
                  val interval : interval -> set
                  val acc_field : record -> Cil_types.fieldinfo -> abstract
                  val upd_field :
                    record -> Cil_types.fieldinfo -> abstract -> record
                  val acc_index : array -> integer -> abstract
                  val upd_index : array -> integer -> abstract -> array
                  module type Indexed =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Dindex :
                    functor (I : Identifiable->
                      sig
                        type t = I.t
                        val define : t -> unit
                        val get_definition : t -> decl
                        val on_definition : (t -> decl -> unit) -> unit
                        val get_ind : t -> integer
                        val has_ind : t -> pred -> bool
                      end
                  module Findex :
                    sig
                      type t = Cil_types.fieldinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Xindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Aindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Tindex :
                    sig
                      type t = Cil_types.compinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module LTindex :
                    sig
                      type t = Cil_types.logic_type
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                end
              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 =
              Path of Funvar_mem.Create.Lookup.path
            | PRef of Funvar_mem.Create.Lookup.path
            | ARef of Funvar_mem.Create.Lookup.path
            | PRpar of Funvar_mem.Create.Lookup.path * int
            | ARpar of Funvar_mem.Create.Lookup.path * int
            | Mloc of M.loc
          val pp_ref :
            string ->
            Format.formatter ->
            Funvar_mem.Create.Lookup.path -> int option -> unit
          val pp_loc :
            Format.formatter -> Funvar_mem.Create.Model.loc -> unit
          val cast_loc_to_int :
            Cil_types.typ ->
            Funvar_mem.Create.Model.loc -> Ctypes.c_int -> M.F.integer
          val cast_int_to_loc :
            Ctypes.c_int ->
            M.F.integer -> Cil_types.typ -> Funvar_mem.Create.Model.loc
          val mloc_of_loc : Funvar_mem.Create.Model.loc -> M.loc
          val loc_of_term :
            Ctypes.c_object -> M.F.abstract -> Funvar_mem.Create.Model.loc
          val term_of_loc : Funvar_mem.Create.Model.loc -> M.F.abstract
          val null : Funvar_mem.Create.Model.loc
          val is_null : Funvar_mem.Create.Model.loc -> M.F.boolean
          val root_equal :
            Funvar_mem.Create.Lookup.root ->
            Funvar_mem.Create.Lookup.root -> bool
          val op_loc :
            (M.loc -> M.loc -> 'a) ->
            (Funvar_mem.Create.Lookup.F.integer ->
             Funvar_mem.Create.Lookup.F.integer -> 'a) ->
            Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.loc -> 'a
          val minus_loc :
            Funvar_mem.Create.Model.loc ->
            Funvar_mem.Create.Model.loc -> M.F.integer
          val lt_loc :
            Funvar_mem.Create.Model.loc ->
            Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.F.pred
          val le_loc :
            Funvar_mem.Create.Model.loc ->
            Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.F.pred
          val le_loc_bool :
            Funvar_mem.Create.Model.loc ->
            Funvar_mem.Create.Model.loc -> M.F.boolean
          val lt_loc_bool :
            Funvar_mem.Create.Model.loc ->
            Funvar_mem.Create.Model.loc -> M.F.boolean
          val equal_loc_bool :
            Funvar_mem.Create.Model.loc ->
            Funvar_mem.Create.Model.loc -> M.F.boolean
          val equal_loc :
            Funvar_mem.Create.Model.loc ->
            Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.F.pred
          val tau_of_loc : Formula.tau
        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
      module L :
        sig
          module F :
            sig
              type var = M.F.var
              type 'a term = 'M.F.term
              type pred = M.F.pred
              type abstract = Formula.m_abstract term
              type integer = Formula.m_integer term
              type real = Formula.m_real term
              type boolean = Formula.m_boolean term
              type record = Formula.m_record term
              type urecord = Formula.m_array term
              type array = Formula.m_array term
              type set = Formula.m_set term
              type name = Formula.m_integer term
              type decl = (var, abstract, pred) Formula.declaration
              val e_int : int -> integer
              val e_call : string -> abstract list -> abstract
              val p_call : string -> abstract list -> pred
              val wrap : 'a term -> abstract
              val unwrap : abstract -> 'a term
              val clear : unit -> unit
              val on_clear : (unit -> unit) -> unit
              val fresh_name : string -> string -> string
              val add_declaration : decl -> unit
              val has_declaration : string -> bool
              val iter_all : (string -> unit) -> (decl -> unit) -> unit
              module type Identifiable =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module type Registry =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                end
              module type Declarator =
                sig
                  type t
                  module H : Hashtbl.S
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                  val clear : unit -> unit
                  val section : Formula.section
                  val declare :
                    t -> string -> (var, abstract, pred) Formula.item
                end
              module DRegister :
                functor (D : Declarator->
                  sig
                    type t = D.t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                  end
              module Varinfo :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = M.F.Varinfo.H.key
                      type 'a t = 'M.F.Varinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Varaddr :
                sig
                  type t = Cil_types.varinfo
                  module H :
                    sig
                      type key = M.F.Varaddr.H.key
                      type 'a t = 'M.F.Varaddr.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Fieldinfo :
                sig
                  type t = Cil_types.fieldinfo
                  module H :
                    sig
                      type key = M.F.Fieldinfo.H.key
                      type 'a t = 'M.F.Fieldinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Compinfo :
                sig
                  type t = Cil_types.compinfo
                  module H :
                    sig
                      type key = M.F.Compinfo.H.key
                      type 'a t = 'M.F.Compinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Arrayinfo :
                sig
                  type t = Ctypes.arrayinfo
                  module H :
                    sig
                      type key = M.F.Arrayinfo.H.key
                      type 'a t = 'M.F.Arrayinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Logicvar :
                sig
                  type t = Cil_types.logic_var
                  module H :
                    sig
                      type key = M.F.Logicvar.H.key
                      type 'a t = 'M.F.Logicvar.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module LTypeinfo :
                sig
                  type t = Cil_types.logic_type
                  module H :
                    sig
                      type key = M.F.LTypeinfo.H.key
                      type 'a t = 'M.F.LTypeinfo.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module Cobject :
                sig
                  type t = Ctypes.c_object
                  module H :
                    sig
                      type key = M.F.Cobject.H.key
                      type 'a t = 'M.F.Cobject.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              module ArrayDim :
                sig
                  type t = Ctypes.c_object * int
                  module H :
                    sig
                      type key = M.F.ArrayDim.H.key
                      type 'a t = 'M.F.ArrayDim.H.t
                      val create : int -> 'a t
                      val clear : 'a t -> unit
                      val copy : 'a t -> 'a t
                      val add : 'a t -> key -> '-> unit
                      val remove : 'a t -> key -> unit
                      val find : 'a t -> key -> 'a
                      val find_all : 'a t -> key -> 'a list
                      val replace : 'a t -> key -> '-> unit
                      val mem : 'a t -> key -> bool
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val length : 'a t -> int
                    end
                  val index : t -> H.key
                  val prefix : string
                  val basename : t -> string
                  val location : t -> Lexing.position option
                  val pp_title : Format.formatter -> t -> unit
                  val pp_descr : Format.formatter -> t -> unit
                end
              val adt_decl : Cil_types.logic_type_info -> string
              val pp_tau : Format.formatter -> Formula.tau -> unit
              val e_true : boolean
              val e_false : boolean
              val e_float : float -> real
              val e_icst : string -> integer
              val e_rcst : string -> real
              val e_int64 : int64 -> integer
              val e_ineg : integer -> integer
              val e_rneg : real -> real
              val e_iop : Formula.int_op -> integer -> integer -> integer
              val e_rop : Formula.real_op -> real -> real -> real
              val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
              val e_rcmp : Formula.cmp_op -> real -> real -> boolean
              val p_icmp : Formula.cmp_op -> integer -> integer -> pred
              val p_rcmp : Formula.cmp_op -> real -> real -> pred
              val e_bnot : integer -> integer
              val e_band : integer -> integer -> integer
              val e_bor : integer -> integer -> integer
              val e_bxor : integer -> integer -> integer
              val e_lshift : integer -> integer -> integer
              val e_rshift : integer -> integer -> integer
              val integer_of_real : real -> integer
              val real_of_integer : integer -> real
              val e_bool : boolean -> integer
              val e_not : boolean -> boolean
              val e_and : boolean -> boolean -> boolean
              val e_or : boolean -> boolean -> boolean
              val e_cond : boolean -> 'a term -> 'a term -> 'a term
              val p_cond : boolean -> pred -> pred -> pred
              val e_getfield : Cil_types.fieldinfo -> record -> abstract
              val e_setfield :
                Cil_types.fieldinfo -> record -> abstract -> record
              val e_access : array -> integer -> abstract
              val e_update : array -> integer -> abstract -> array
              val p_true : pred
              val p_false : pred
              val p_bool : boolean -> pred
              val p_and : pred -> pred -> pred
              val p_or : pred -> pred -> pred
              val p_xor : pred -> pred -> pred
              val p_not : pred -> pred
              val p_implies : pred -> pred -> pred
              val p_iff : pred -> pred -> pred
              val p_eq : 'a term -> 'a term -> pred
              val p_neq : 'a term -> 'a term -> pred
              val p_conj : pred list -> pred
              val p_disj : pred list -> pred
              val p_named : string -> pred -> pred
              val is_true : pred -> bool
              val is_false : pred -> bool
              val huge_term : int -> 'a term -> bool
              val huge_pred : int -> pred -> bool
              type pool = M.F.pool
              val pool : unit -> pool
              val p_fresh : pool -> string -> Formula.kind -> var
              val p_freshen : pool -> var -> var
              val var : var -> 'a term
              val eq_var : var -> var -> bool
              val name_of_var : var -> string
              val basename_of_var : var -> string
              val tau_of_var : var -> Formula.tau
              val kind_of_var : var -> Formula.kind
              val term_has_var : var list -> 'a term -> bool
              val pred_has_var : var list -> pred -> bool
              val term_calls : string -> 'a term -> bool
              val pred_calls : string -> pred -> bool
              val term_closed : 'a term -> bool
              val pred_closed : pred -> bool
              val freevars : pred -> var list
              val p_forall : var list -> pred -> pred
              val p_exists : var list -> pred -> pred
              val p_subst :
                (var -> var option) -> var -> 'a term -> pred -> pred
              val e_subst :
                (var -> var option) -> var -> 'a term -> 'b term -> 'b term
              val e_rename : (var * var) list -> 'a term -> 'a term
              val equal_terms : 'a term -> 'a term -> bool
              type alpha = M.F.alpha
              val empty_alpha : alpha
              val fold_alpha : (var -> var -> '-> 'a) -> alpha -> '-> 'a
              val p_more_alpha_cv : alpha -> pred -> alpha * pred
              val p_alpha_cv : pred -> var list * pred
              val pp_var : Format.formatter -> var -> unit
              val pp_section : Format.formatter -> string -> unit
              val pp_term : Format.formatter -> 'a term -> unit
              val pp_pred : Format.formatter -> pred -> unit
              val pp_decl : Format.formatter -> decl -> unit
              val pp_goal : Format.formatter -> string -> pred -> unit
              val pp_vkind : Format.formatter -> Formula.kind -> unit
              val e_app0 : string -> 'a term
              val e_app1 : string -> 'a term -> 'b term
              val e_app2 : string -> 'a term -> 'b term -> 'c term
              val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
              val e_app4 :
                string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
              val e_app5 :
                string ->
                'a term ->
                'b term -> 'c term -> 'd term -> 'e term -> 'f term
              val p_app0 : string -> pred
              val p_app1 : string -> 'a term -> pred
              val p_app2 : string -> 'a term -> 'b term -> pred
              val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
              val p_app4 :
                string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
              val p_app5 :
                string ->
                'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
              val dummy : unit -> pred
              val i_zero : integer
              val r_zero : real
              val i_one : integer
              val i_add : integer -> integer -> integer
              val i_mult : integer -> integer -> integer
              val i_sub : integer -> integer -> integer
              val guard : Ctypes.c_int -> integer -> pred
              val modulo : Ctypes.c_int -> integer -> integer
              val i_convert :
                Ctypes.c_int -> Ctypes.c_int -> integer -> integer
              type interval =
                M.F.interval = {
                inf : integer option;
                sup : integer option;
              }
              type 'a assigned =
                'M.F.assigned =
                  Aloc of Ctypes.c_object * 'a
                | Arange of Ctypes.c_object * 'a * interval
              type havoc =
                M.F.havoc =
                  Fresh of var
                | Update of var * ((var * var) list -> abstract)
              val pp_interval : Format.formatter -> interval -> unit
              val set_range_index : array -> interval -> array
              val empty : set
              val singleton : abstract -> set
              val union : set -> set -> set
              val unions : set list -> set
              val inter : set -> set -> set
              val remove : set -> set -> set
              val set_of_list : abstract list -> set
              val add_set : set -> set -> set
              val mult_set : set -> set -> set
              val neg_set : set -> set
              val interval : interval -> set
              val acc_field : record -> Cil_types.fieldinfo -> abstract
              val upd_field :
                record -> Cil_types.fieldinfo -> abstract -> record
              val acc_index : array -> integer -> abstract
              val upd_index : array -> integer -> abstract -> array
              module type Indexed =
                sig
                  type t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Dindex :
                functor (I : Identifiable->
                  sig
                    type t = I.t
                    val define : t -> unit
                    val get_definition : t -> decl
                    val on_definition : (t -> decl -> unit) -> unit
                    val get_ind : t -> integer
                    val has_ind : t -> pred -> bool
                  end
              module Findex :
                sig
                  type t = Cil_types.fieldinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Xindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Aindex :
                sig
                  type t = Cil_types.varinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module Tindex :
                sig
                  type t = Cil_types.compinfo
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
              module LTindex :
                sig
                  type t = Cil_types.logic_type
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
            end
          type context = M.L.context
          type bindings = M.L.bindings
          val closed : bindings
          val close : bindings -> F.pred -> F.pred
          val push : string -> F.pool -> bindings -> context
          val pop : string -> context -> bindings
          val kill : string -> context -> unit
          val flush : string -> context -> F.pred -> F.pred
          val term_such_that :
            Formula.tau -> ('F.term -> F.pred) -> 'F.term
          val forall : F.var list -> F.pred -> F.pred
          val exists : F.var list -> F.pred -> F.pred
          val subst : F.var -> 'F.term -> F.pred -> F.pred
          val fresh : string -> Formula.kind -> F.var
          val alpha : F.var -> F.var option
          val pool : unit -> F.pool
          val vkind_of_var : F.var -> Formula.kind
          val has_context_vars : F.var list -> F.pred -> bool
          val has_type : F.abstract -> Cil_types.logic_type -> F.pred
          val is_comp : Cil_types.compinfo -> F.abstract -> F.pred
          val is_array : Ctypes.arrayinfo -> F.abstract -> F.pred
          val apply : (F.var * F.var) list -> 'F.term -> 'F.term
          val havoc_static : F.havoc list -> F.pred -> F.pred
          val havoc_inductive : F.havoc list -> F.pred -> F.pred
        end
      type decl = M.F.decl
      val value_of_mvalue : M.value -> value
      val mvalue_of_value : value -> M.value
      module Xmap :
        sig
          type key = Cil_datatype.Varinfo.t
          type 'a t = 'Cil_datatype.Varinfo.Map.t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val max_binding : 'a t -> key * 'a
          val choose : 'a t -> key * 'a
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          module Key :
            sig
              type t = key
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
          module Make :
            functor (Data : Datatype.S->
              sig
                type t = Data.t t
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
        end
      type var_info = {
        v_var : F.var;
        v_arity : int;
        v_is_array : bool;
        v_type : Ctypes.c_object;
      }
      type vars = Funvar_mem.Create.var_info Funvar_mem.Create.Xmap.t
      module Lmap :
        sig
          type key = Cil_datatype.Logic_var.t
          type 'a t = 'Cil_datatype.Logic_var.Map.t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val max_binding : 'a t -> key * 'a
          val choose : 'a t -> key * 'a
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          module Key :
            sig
              type t = key
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
          module Make :
            functor (Data : Datatype.S->
              sig
                type t = Data.t t
                val ty : t Type.t
                val name : string
                val descr : t Descr.t
                val packed_descr : Structural_descr.pack
                val reprs : t list
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val hash : t -> int
                val pretty_code : Format.formatter -> t -> unit
                val internal_pretty_code :
                  Type.precedence -> Format.formatter -> t -> unit
                val pretty : Format.formatter -> t -> unit
                val varname : t -> string
                val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                val copy : t -> t
              end
        end
      type formal = Fpref of int | Faref of int
      type byrefparam = {
        bref_var : F.var;
        bref_formal : Funvar_mem.Create.formal;
      }
      type mem = {
        mem : M.mem;
        mutable vars : Funvar_mem.Create.vars;
        mutable formals :
          Funvar_mem.Create.byrefparam Funvar_mem.Create.Lmap.t;
      }
      val mem : unit -> Funvar_mem.Create.mem
      val global_scope : '-> '-> 'b
      val global : '-> unit
      val get_logic_funvar :
        Funvar_mem.Create.mem ->
        int -> Funvar_mem.Create.Lmap.key -> bool -> F.var
      val get_c_funvar :
        Funvar_mem.Create.mem ->
        int -> Funvar_mem.Create.Xmap.key -> bool -> F.var
      val get_funvar :
        Funvar_mem.Create.mem ->
        int -> Funvar_mem.Create.Lookup.root -> bool -> F.var
      val mk_path :
        Funvar_mem.Create.Lookup.root ->
        M.mem -> Funvar_mem.Create.Lookup.path
      val mk_pref :
        Funvar_mem.Create.Lookup.root ->
        M.mem ->
        int ->
        Funvar_mem.Create.Lookup.F.var option ->
        Funvar_mem.Create.Lookup.path
      val mk_aref :
        Funvar_mem.Create.Lookup.root ->
        M.mem ->
        int ->
        Funvar_mem.Create.Lookup.F.var option ->
        Funvar_mem.Create.Lookup.path
      val cvar :
        Funvar_mem.Create.mem ->
        Cil_types.varinfo -> Funvar_mem.Create.Model.loc
      val lvar :
        Funvar_mem.Create.mem ->
        Cil_types.logic_var ->
        Funvar_mem.Create.Lookup.F.var -> Funvar_mem.Create.Model.loc
      val inner_loc : Funvar_mem.Create.Model.loc -> M.F.abstract
      val add_index :
        Funvar_mem.Create.Lookup.path ->
        Funvar_mem.Create.Lookup.F.integer ->
        Ctypes.c_object -> Funvar_mem.Create.Lookup.path
      val shift :
        Funvar_mem.Create.Model.loc ->
        Ctypes.c_object -> M.F.integer -> Funvar_mem.Create.Model.loc
      val index :
        Funvar_mem.Create.Model.loc ->
        Ctypes.c_object -> M.F.integer -> Funvar_mem.Create.Model.loc
      val add_field :
        Funvar_mem.Create.Lookup.path ->
        Cil_types.fieldinfo -> Funvar_mem.Create.Lookup.path
      val field :
        Funvar_mem.Create.Model.loc ->
        Cil_types.fieldinfo -> Funvar_mem.Create.Model.loc
      val startof :
        Funvar_mem.Create.Model.loc ->
        Ctypes.c_object -> Funvar_mem.Create.Model.loc
      val cast_loc_to_loc :
        Cil_types.typ ->
        Cil_types.typ ->
        Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.loc
      val fun_load :
        Funvar_mem.Create.mem ->
        Funvar_mem.Create.Lookup.path -> bool -> value
      val load :
        Funvar_mem.Create.mem ->
        Ctypes.c_object -> Funvar_mem.Create.Model.loc -> value
      val massigned : loc F.assigned -> M.loc F.assigned
      type m_dzone = M.m_dzone
      type dzone = M.dzone
      val tau_of_dzone : Formula.tau
      val dzone_assigned : Funvar_mem.Create.mem -> loc F.assigned -> M.dzone
      val dzone_subset : M.dzone -> M.dzone -> M.F.pred
      val dzone_union : M.dzone -> M.dzone -> M.dzone
      val dzone_empty : unit -> M.dzone
      val effect_supported : bool
      val base_address :
        Funvar_mem.Create.mem ->
        Funvar_mem.Create.Model.loc -> Funvar_mem.Create.Model.loc
      val block_length :
        Funvar_mem.Create.mem -> Funvar_mem.Create.Model.loc -> M.F.integer
      val valid : Funvar_mem.Create.mem -> loc F.assigned -> M.F.pred
      val separated :
        Funvar_mem.Create.mem -> loc F.assigned -> loc F.assigned -> M.F.pred
      val pp_formal_simple :
        Format.formatter -> Funvar_mem.Create.formal -> unit
      val pp_formal :
        Format.formatter ->
        Funvar_mem.Create.formal * Cil_types.logic_var -> unit
      val userdef_ref_has_cvar : Cil_types.logic_var -> bool
      val userdef_is_ref_param : Cil_types.logic_var -> bool
      val userdef_ref_signature :
        Funvar_mem.Create.mem ->
        (F.var * Funvar_mem.Create.Lmap.key * Funvar_mem.Create.formal) list
      val userdef_ref_apply :
        Funvar_mem.Create.mem -> Funvar_mem.Create.formal -> loc -> value
      type closure =
          Fclos of int * bool * Cil_types.varinfo
        | Mclos of M.closure
      val pp_closure : Format.formatter -> Funvar_mem.Create.closure -> unit
      val userdef_mem_signature :
        Funvar_mem.Create.mem -> (F.var * Funvar_mem.Create.closure) list
      val userdef_mem_apply :
        Funvar_mem.Create.mem ->
        Funvar_mem.Create.closure -> Formula.m_abstract F.term
      val update :
        at:Funvar_mem.Create.mem ->
        here:Funvar_mem.Create.mem -> M.F.pred -> Funvar_mem.Create.L.F.pred
      val quantify :
        Funvar_mem.Create.mem -> M.F.pred -> Funvar_mem.Create.L.F.pred
      val update_offset :
        (Funvar_mem.Create.Lookup.F.abstract -> F.abstract) ->
        Funvar_mem.Create.Lookup.F.abstract ->
        Funvar_mem.Create.Lookup.poffset list -> F.abstract
      val store :
        Funvar_mem.Create.mem ->
        Funvar_mem.Create.Lookup.path ->
        value ->
        bool -> Funvar_mem.Create.L.F.pred -> Funvar_mem.Create.L.F.pred
      val subst_lval :
        Funvar_mem.Create.mem ->
        Ctypes.c_object ->
        Funvar_mem.Create.Model.loc ->
        value -> Funvar_mem.Create.L.F.pred -> Funvar_mem.Create.L.F.pred
      val subst_havoc :
        Funvar_mem.Create.mem ->
        Funvar_mem.Create.Model.loc F.assigned -> F.havoc list
      val assigns_goal :
        Funvar_mem.Create.mem ->
        Funvar_mem.Create.Model.loc F.assigned list ->
        Funvar_mem.Create.mem -> M.F.pred
      val assigns_supported : bool
      val local_scope :
        Funvar_mem.Create.mem ->
        Cil_types.varinfo list -> Mcfg.scope -> M.F.pred -> M.F.pred
    end