functor (D : Mdata.S->
  functor
    (A : sig
           module D :
             sig
               module F :
                 sig
                   type 'a term = 'D.F.term
                   type pred = D.F.pred
                   val e_int : int -> Formula.integer term
                   val e_call :
                     string ->
                     Formula.abstract term list -> Formula.abstract term
                   val p_call : string -> Formula.abstract term list -> pred
                   val wrap : 'a term -> Formula.abstract term
                   val unwrap : Formula.abstract term -> 'a term
                   val e_true : Formula.boolean term
                   val e_false : Formula.boolean term
                   val e_int : int -> Formula.integer term
                   val e_float : float -> Formula.real term
                   val e_icst : string -> Formula.integer term
                   val e_rcst : string -> Formula.real term
                   val e_int64 : int64 -> Formula.integer term
                   val e_ineg : Formula.integer term -> Formula.integer term
                   val e_rneg : Formula.real term -> Formula.real term
                   val e_iop :
                     Formula.integer_op ->
                     Formula.integer term ->
                     Formula.integer term -> Formula.integer term
                   val e_rop :
                     Formula.real_op ->
                     Formula.real term ->
                     Formula.real term -> Formula.real term
                   val e_icmp :
                     Formula.cmp_op ->
                     Formula.integer term ->
                     Formula.integer term -> Formula.boolean term
                   val e_rcmp :
                     Formula.cmp_op ->
                     Formula.real term ->
                     Formula.real term -> Formula.boolean term
                   val p_icmp :
                     Formula.cmp_op ->
                     Formula.integer term -> Formula.integer term -> pred
                   val p_rcmp :
                     Formula.cmp_op ->
                     Formula.real term -> Formula.real term -> pred
                   val e_bnot : Formula.integer term -> Formula.integer term
                   val e_band :
                     Formula.integer term ->
                     Formula.integer term -> Formula.integer term
                   val e_bor :
                     Formula.integer term ->
                     Formula.integer term -> Formula.integer term
                   val e_bxor :
                     Formula.integer term ->
                     Formula.integer term -> Formula.integer term
                   val e_lshift :
                     Formula.integer term ->
                     Formula.integer term -> Formula.integer term
                   val e_rshift :
                     Formula.integer term ->
                     Formula.integer term -> Formula.integer term
                   val integer_of_real :
                     Formula.real term -> Formula.integer term
                   val real_of_integer :
                     Formula.integer term -> Formula.real term
                   val e_bool : Formula.boolean term -> Formula.integer term
                   val e_not : Formula.boolean term -> Formula.boolean term
                   val e_and :
                     Formula.boolean term ->
                     Formula.boolean term -> Formula.boolean term
                   val e_or :
                     Formula.boolean term ->
                     Formula.boolean term -> Formula.boolean term
                   val e_cond :
                     Formula.boolean term -> 'a term -> 'a term -> 'a term
                   val p_cond : Formula.boolean term -> pred -> pred -> pred
                   val p_true : pred
                   val p_false : pred
                   val p_bool : Formula.boolean term -> 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 var = D.F.var
                   type pool = D.F.pool
                   val pool : unit -> pool
                   val fresh : pool -> string -> Formula.kind -> var
                   val freshen : pool -> var -> var
                   val var : var -> 'a term
                   val eq_var : var -> var -> bool
                   val name_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_closed : 'a term -> bool
                   val pred_closed : pred -> bool
                   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 = D.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_term : Format.formatter -> 'a term -> unit
                   val pp_pred : Format.formatter -> pred -> unit
                   val pp_decl :
                     Format.formatter -> pred Formula.declaration -> unit
                   val pp_goal : Format.formatter -> string -> pred -> unit
                 end
               type format = Formula.m_format F.term
               type abstract = Formula.abstract F.term
               type integer = Formula.integer F.term
               type real = Formula.real F.term
               type boolean = Formula.boolean F.term
               type record = Formula.m_array F.term
               type urecord = Formula.m_array F.term
               type array = Formula.m_array F.term
               type set = Formula.m_set F.term
               type name = Formula.integer F.term
               type pointer = Formula.m_pointer F.term
               val pp_kind : Format.formatter -> Mdata.kind -> unit
               type interval =
                 D.interval = {
                 inf : integer option;
                 sup : integer option;
               }
               type 'a assigned =
                 'D.assigned =
                   Aloc of Ctypes.c_object * 'a
                 | Arange of Ctypes.c_object * 'a * interval
               val pp_interval : Format.formatter -> interval -> unit
               val e_app0 : string -> 'F.term
               val e_app1 : string -> 'F.term -> 'F.term
               val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
               val e_app3 :
                 string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
               val e_app4 :
                 string ->
                 'F.term ->
                 'F.term -> 'F.term -> 'F.term -> 'F.term
               val e_app5 :
                 string ->
                 'F.term ->
                 'F.term ->
                 'F.term -> 'F.term -> 'F.term -> 'F.term
               val p_app0 : string -> F.pred
               val p_app1 : string -> 'F.term -> F.pred
               val p_app2 : string -> 'F.term -> 'F.term -> F.pred
               val p_app3 :
                 string -> 'F.term -> 'F.term -> 'F.term -> F.pred
               val p_app4 :
                 string ->
                 'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
               val p_app5 :
                 string ->
                 'F.term ->
                 'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
               val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
               type context = D.context
               type bindings = D.bindings
               class type hint =
                 object
                   method capture : F.var list -> unit
                   method has_var : F.var list -> bool
                   method pretty : Format.formatter -> unit
                   method subst : F.var -> Formula.abstract F.term -> unit
                 end
               val closed : bindings
               val close : bindings -> F.pred -> F.pred
               val capture : hint list -> bindings -> unit
               val push :
                 string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
               val alpha : F.var -> F.var option
               val pool : unit -> F.pool
               val vkind_of_var : F.var -> Mdata.vkind
               val has_vars : F.var list -> F.pred -> bool
               type substitution = D.substitution
               val apply : substitution -> 'F.term -> 'F.term
               type havoc =
                 D.havoc =
                   Fresh of F.var
                 | Update of F.var *
                     (substitution -> Formula.abstract F.term)
               val havoc_static : havoc list -> F.pred -> F.pred
               val havoc_inductive : havoc list -> F.pred -> F.pred
               val clear : unit -> unit
               val on_clear : (unit -> unit) -> unit
               val fresh_name : string -> string -> string
               val add_declaration : F.pred Formula.declaration -> unit
               val iter :
                 Formula.section ->
                 (F.pred Formula.declaration -> unit) -> unit
               val iter_all : (F.pred Formula.declaration -> unit) -> unit
               val dummy : unit -> F.pred
               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 -> Log.source 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 -> F.pred Formula.declaration
                   val on_definition :
                     (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
                 end
               module Register :
                 functor (D : Declarator->
                   sig
                     type t = D.t
                     val define : t -> unit
                     val get_definition : t -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> unit) -> unit
                   end
               module Varinfo :
                 sig
                   type t = Cil_types.varinfo
                   module H :
                     sig
                       type key = D.Varinfo.H.key
                       type 'a t = 'D.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 -> Log.source 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 = D.Varaddr.H.key
                       type 'a t = 'D.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 -> Log.source 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 = D.Fieldinfo.H.key
                       type 'a t = 'D.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 -> Log.source 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 = D.Compinfo.H.key
                       type 'a t = 'D.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 -> Log.source 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 = D.Arrayinfo.H.key
                       type 'a t = 'D.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 -> Log.source 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 = D.Logicvar.H.key
                       type 'a t = 'D.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 -> Log.source option
                   val pp_title : Format.formatter -> t -> unit
                   val pp_descr : Format.formatter -> t -> unit
                 end
               module type Indexed =
                 sig
                   type t
                   val define : t -> unit
                   val get_definition : t -> F.pred Formula.declaration
                   val on_definition :
                     (t -> F.pred Formula.declaration -> unit) -> unit
                   val get_ind : t -> integer
                 end
               module Dindex :
                 functor (I : Identifiable->
                   sig
                     type t = I.t
                     val define : t -> unit
                     val get_definition : t -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> unit) -> unit
                     val get_ind : t -> integer
                   end
               module Findex :
                 sig
                   type t = Cil_types.fieldinfo
                   val define : t -> unit
                   val get_definition : t -> F.pred Formula.declaration
                   val on_definition :
                     (t -> F.pred Formula.declaration -> unit) -> unit
                   val get_ind : t -> integer
                 end
               module Xindex :
                 sig
                   type t = Cil_types.varinfo
                   val define : t -> unit
                   val get_definition : t -> F.pred Formula.declaration
                   val on_definition :
                     (t -> F.pred Formula.declaration -> unit) -> unit
                   val get_ind : t -> integer
                 end
               module Aindex :
                 sig
                   type t = Cil_types.varinfo
                   val define : t -> unit
                   val get_definition : t -> F.pred Formula.declaration
                   val on_definition :
                     (t -> F.pred Formula.declaration -> unit) -> unit
                   val get_ind : t -> integer
                 end
               module Tindex :
                 sig
                   type t = Cil_types.compinfo
                   val define : t -> unit
                   val get_definition : t -> F.pred Formula.declaration
                   val on_definition :
                     (t -> F.pred Formula.declaration -> unit) -> unit
                   val get_ind : t -> integer
                 end
               val modulo : Ctypes.c_int -> integer -> integer
               val guard : Ctypes.c_int -> integer -> F.pred
               val i_convert :
                 Ctypes.c_int -> Ctypes.c_int -> integer -> integer
               val round : Ctypes.c_float -> real -> real
               val f_guard : Ctypes.c_float -> real -> F.pred
               val f_convert :
                 Ctypes.c_float -> Ctypes.c_float -> real -> real
               val has_type : abstract -> Cil_types.logic_type -> F.pred
               val get_range_index : array -> interval -> abstract
               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 equal_pointer_bool : pointer -> pointer -> boolean
               val lt_pointer_bool : pointer -> pointer -> boolean
               val le_pointer_bool : pointer -> pointer -> boolean
               val lt_pointer : pointer -> pointer -> F.pred
               val le_pointer : pointer -> pointer -> F.pred
               val minus_pointer : pointer -> pointer -> integer
               val is_null : pointer -> boolean
               val null : pointer
               val tau_of_object : Ctypes.c_object -> Formula.tau
               val tau_of_ctype : Cil_types.typ -> Formula.tau
               val int_format : format
               val real_format : format
               val pointer_format : format
               val record_format : format
               val urecord_format : format
               val array_format : format -> format
               val format_of_object : Ctypes.c_object -> format
               val decode : format -> abstract -> 'F.term
               val encode : format -> 'F.term -> abstract
               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
               val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
               val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
               val eq_record :
                 Cil_types.compinfo -> record -> record -> F.pred
             end
           val i_neg : Ctypes.c_int -> D.integer -> D.integer
           val i_op :
             Ctypes.c_int ->
             Formula.integer_op -> D.integer -> D.integer -> D.integer
           val i_cmp :
             Ctypes.c_int ->
             Formula.cmp_op -> D.integer -> D.integer -> D.boolean
           val bits_not : Ctypes.c_int -> D.integer -> D.integer
           val bits_and : Ctypes.c_int -> D.integer -> D.integer -> D.integer
           val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
           val bits_xor : Ctypes.c_int -> D.integer -> D.integer -> D.integer
           val bits_lshift :
             Ctypes.c_int -> D.integer -> D.integer -> D.integer
           val bits_rshift :
             Ctypes.c_int -> D.integer -> D.integer -> D.integer
         end->
    functor
      (R : sig
             module D :
               sig
                 module F :
                   sig
                     type 'a term = 'D.F.term
                     type pred = D.F.pred
                     val e_int : int -> Formula.integer term
                     val e_call :
                       string ->
                       Formula.abstract term list -> Formula.abstract term
                     val p_call :
                       string -> Formula.abstract term list -> pred
                     val wrap : 'a term -> Formula.abstract term
                     val unwrap : Formula.abstract term -> 'a term
                     val e_true : Formula.boolean term
                     val e_false : Formula.boolean term
                     val e_int : int -> Formula.integer term
                     val e_float : float -> Formula.real term
                     val e_icst : string -> Formula.integer term
                     val e_rcst : string -> Formula.real term
                     val e_int64 : int64 -> Formula.integer term
                     val e_ineg :
                       Formula.integer term -> Formula.integer term
                     val e_rneg : Formula.real term -> Formula.real term
                     val e_iop :
                       Formula.integer_op ->
                       Formula.integer term ->
                       Formula.integer term -> Formula.integer term
                     val e_rop :
                       Formula.real_op ->
                       Formula.real term ->
                       Formula.real term -> Formula.real term
                     val e_icmp :
                       Formula.cmp_op ->
                       Formula.integer term ->
                       Formula.integer term -> Formula.boolean term
                     val e_rcmp :
                       Formula.cmp_op ->
                       Formula.real term ->
                       Formula.real term -> Formula.boolean term
                     val p_icmp :
                       Formula.cmp_op ->
                       Formula.integer term -> Formula.integer term -> pred
                     val p_rcmp :
                       Formula.cmp_op ->
                       Formula.real term -> Formula.real term -> pred
                     val e_bnot :
                       Formula.integer term -> Formula.integer term
                     val e_band :
                       Formula.integer term ->
                       Formula.integer term -> Formula.integer term
                     val e_bor :
                       Formula.integer term ->
                       Formula.integer term -> Formula.integer term
                     val e_bxor :
                       Formula.integer term ->
                       Formula.integer term -> Formula.integer term
                     val e_lshift :
                       Formula.integer term ->
                       Formula.integer term -> Formula.integer term
                     val e_rshift :
                       Formula.integer term ->
                       Formula.integer term -> Formula.integer term
                     val integer_of_real :
                       Formula.real term -> Formula.integer term
                     val real_of_integer :
                       Formula.integer term -> Formula.real term
                     val e_bool :
                       Formula.boolean term -> Formula.integer term
                     val e_not : Formula.boolean term -> Formula.boolean term
                     val e_and :
                       Formula.boolean term ->
                       Formula.boolean term -> Formula.boolean term
                     val e_or :
                       Formula.boolean term ->
                       Formula.boolean term -> Formula.boolean term
                     val e_cond :
                       Formula.boolean term -> 'a term -> 'a term -> 'a term
                     val p_cond :
                       Formula.boolean term -> pred -> pred -> pred
                     val p_true : pred
                     val p_false : pred
                     val p_bool : Formula.boolean term -> 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 var = D.F.var
                     type pool = D.F.pool
                     val pool : unit -> pool
                     val fresh : pool -> string -> Formula.kind -> var
                     val freshen : pool -> var -> var
                     val var : var -> 'a term
                     val eq_var : var -> var -> bool
                     val name_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_closed : 'a term -> bool
                     val pred_closed : pred -> bool
                     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 = D.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_term : Format.formatter -> 'a term -> unit
                     val pp_pred : Format.formatter -> pred -> unit
                     val pp_decl :
                       Format.formatter -> pred Formula.declaration -> unit
                     val pp_goal : Format.formatter -> string -> pred -> unit
                   end
                 type format = Formula.m_format F.term
                 type abstract = Formula.abstract F.term
                 type integer = Formula.integer F.term
                 type real = Formula.real F.term
                 type boolean = Formula.boolean F.term
                 type record = Formula.m_array F.term
                 type urecord = Formula.m_array F.term
                 type array = Formula.m_array F.term
                 type set = Formula.m_set F.term
                 type name = Formula.integer F.term
                 type pointer = Formula.m_pointer F.term
                 val pp_kind : Format.formatter -> Mdata.kind -> unit
                 type interval =
                   D.interval = {
                   inf : integer option;
                   sup : integer option;
                 }
                 type 'a assigned =
                   'D.assigned =
                     Aloc of Ctypes.c_object * 'a
                   | Arange of Ctypes.c_object * 'a * interval
                 val pp_interval : Format.formatter -> interval -> unit
                 val e_app0 : string -> 'F.term
                 val e_app1 : string -> 'F.term -> 'F.term
                 val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
                 val e_app3 :
                   string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
                 val e_app4 :
                   string ->
                   'F.term ->
                   'F.term -> 'F.term -> 'F.term -> 'F.term
                 val e_app5 :
                   string ->
                   'F.term ->
                   'F.term ->
                   'F.term -> 'F.term -> 'F.term -> 'F.term
                 val p_app0 : string -> F.pred
                 val p_app1 : string -> 'F.term -> F.pred
                 val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                 val p_app3 :
                   string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                 val p_app4 :
                   string ->
                   'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                 val p_app5 :
                   string ->
                   'F.term ->
                   'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                 val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
                 type context = D.context
                 type bindings = D.bindings
                 class type hint =
                   object
                     method capture : F.var list -> unit
                     method has_var : F.var list -> bool
                     method pretty : Format.formatter -> unit
                     method subst : F.var -> Formula.abstract F.term -> unit
                   end
                 val closed : bindings
                 val close : bindings -> F.pred -> F.pred
                 val capture : hint list -> bindings -> unit
                 val push :
                   string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
                 val alpha : F.var -> F.var option
                 val pool : unit -> F.pool
                 val vkind_of_var : F.var -> Mdata.vkind
                 val has_vars : F.var list -> F.pred -> bool
                 type substitution = D.substitution
                 val apply : substitution -> 'F.term -> 'F.term
                 type havoc =
                   D.havoc =
                     Fresh of F.var
                   | Update of F.var *
                       (substitution -> Formula.abstract F.term)
                 val havoc_static : havoc list -> F.pred -> F.pred
                 val havoc_inductive : havoc list -> F.pred -> F.pred
                 val clear : unit -> unit
                 val on_clear : (unit -> unit) -> unit
                 val fresh_name : string -> string -> string
                 val add_declaration : F.pred Formula.declaration -> unit
                 val iter :
                   Formula.section ->
                   (F.pred Formula.declaration -> unit) -> unit
                 val iter_all : (F.pred Formula.declaration -> unit) -> unit
                 val dummy : unit -> F.pred
                 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 -> Log.source 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 -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
                   end
                 module Register :
                   functor (D : Declarator->
                     sig
                       type t = D.t
                       val define : t -> unit
                       val get_definition : t -> F.pred Formula.declaration
                       val on_definition :
                         (t -> F.pred Formula.declaration -> unit) -> unit
                     end
                 module Varinfo :
                   sig
                     type t = Cil_types.varinfo
                     module H :
                       sig
                         type key = D.Varinfo.H.key
                         type 'a t = 'D.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 -> Log.source 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 = D.Varaddr.H.key
                         type 'a t = 'D.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 -> Log.source 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 = D.Fieldinfo.H.key
                         type 'a t = 'D.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 -> Log.source 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 = D.Compinfo.H.key
                         type 'a t = 'D.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 -> Log.source 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 = D.Arrayinfo.H.key
                         type 'a t = 'D.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 -> Log.source 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 = D.Logicvar.H.key
                         type 'a t = 'D.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 -> Log.source option
                     val pp_title : Format.formatter -> t -> unit
                     val pp_descr : Format.formatter -> t -> unit
                   end
                 module type Indexed =
                   sig
                     type t
                     val define : t -> unit
                     val get_definition : t -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> unit) -> unit
                     val get_ind : t -> integer
                   end
                 module Dindex :
                   functor (I : Identifiable->
                     sig
                       type t = I.t
                       val define : t -> unit
                       val get_definition : t -> F.pred Formula.declaration
                       val on_definition :
                         (t -> F.pred Formula.declaration -> unit) -> unit
                       val get_ind : t -> integer
                     end
                 module Findex :
                   sig
                     type t = Cil_types.fieldinfo
                     val define : t -> unit
                     val get_definition : t -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> unit) -> unit
                     val get_ind : t -> integer
                   end
                 module Xindex :
                   sig
                     type t = Cil_types.varinfo
                     val define : t -> unit
                     val get_definition : t -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> unit) -> unit
                     val get_ind : t -> integer
                   end
                 module Aindex :
                   sig
                     type t = Cil_types.varinfo
                     val define : t -> unit
                     val get_definition : t -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> unit) -> unit
                     val get_ind : t -> integer
                   end
                 module Tindex :
                   sig
                     type t = Cil_types.compinfo
                     val define : t -> unit
                     val get_definition : t -> F.pred Formula.declaration
                     val on_definition :
                       (t -> F.pred Formula.declaration -> unit) -> unit
                     val get_ind : t -> integer
                   end
                 val modulo : Ctypes.c_int -> integer -> integer
                 val guard : Ctypes.c_int -> integer -> F.pred
                 val i_convert :
                   Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                 val round : Ctypes.c_float -> real -> real
                 val f_guard : Ctypes.c_float -> real -> F.pred
                 val f_convert :
                   Ctypes.c_float -> Ctypes.c_float -> real -> real
                 val has_type : abstract -> Cil_types.logic_type -> F.pred
                 val get_range_index : array -> interval -> abstract
                 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 equal_pointer_bool : pointer -> pointer -> boolean
                 val lt_pointer_bool : pointer -> pointer -> boolean
                 val le_pointer_bool : pointer -> pointer -> boolean
                 val lt_pointer : pointer -> pointer -> F.pred
                 val le_pointer : pointer -> pointer -> F.pred
                 val minus_pointer : pointer -> pointer -> integer
                 val is_null : pointer -> boolean
                 val null : pointer
                 val tau_of_object : Ctypes.c_object -> Formula.tau
                 val tau_of_ctype : Cil_types.typ -> Formula.tau
                 val int_format : format
                 val real_format : format
                 val pointer_format : format
                 val record_format : format
                 val urecord_format : format
                 val array_format : format -> format
                 val format_of_object : Ctypes.c_object -> format
                 val decode : format -> abstract -> 'F.term
                 val encode : format -> 'F.term -> abstract
                 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
                 val equal :
                   Ctypes.c_object -> abstract -> abstract -> F.pred
                 val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
                 val eq_record :
                   Cil_types.compinfo -> record -> record -> F.pred
               end
             val f_neg : Ctypes.c_float -> D.real -> D.real
             val f_op :
               Ctypes.c_float ->
               Formula.real_op -> D.real -> D.real -> D.real
             val f_cmp :
               Ctypes.c_float ->
               Formula.cmp_op -> D.real -> D.real -> D.boolean
           end->
      sig
        val unsupported :
          ?model:string ->
          ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
        module Shared :
          sig
            module Hlib :
              sig
                val addr : D.name -> D.pointer
                val shift_pointer :
                  D.pointer -> Formula.integer D.F.term -> D.pointer
                val shift_field : D.pointer -> D.name -> D.pointer
                val shift_ufield : D.pointer -> D.name -> D.pointer
                val shift_index :
                  D.pointer -> Formula.integer D.F.term -> D.pointer
                val havoc_index :
                  D.array -> Formula.integer D.F.term -> D.array
                val havoc_field : D.record -> D.name -> D.record
                val havoc_ufield : D.urecord -> D.name -> D.urecord
                val base : D.pointer -> D.pointer
                val block_length : D.pointer -> Formula.integer D.F.term
                val valid_pointer : D.pointer -> D.F.pred
                val valid_range : D.pointer -> D.set -> D.F.pred
                val separated : D.pointer -> D.pointer -> D.F.pred
                val array_length : D.pointer -> Formula.integer D.F.term
              end
            val get_array_length :
              Cil_types.typ -> Formula.integer D.F.term option
            val mk_v_array_length :
              D.pointer -> Formula.integer D.F.term -> D.F.pred
            module Globals :
              sig
                type t = Cil_types.varinfo
                val define : t -> unit
                val get_definition : t -> D.F.pred Formula.declaration
                val on_definition :
                  (t -> D.F.pred Formula.declaration -> unit) -> unit
              end
          end
        module F :
          sig
            type 'a term = 'D.F.term
            type pred = D.F.pred
            val e_int : int -> Formula.integer term
            val e_call :
              string -> Formula.abstract term list -> Formula.abstract term
            val p_call : string -> Formula.abstract term list -> pred
            val wrap : 'a term -> Formula.abstract term
            val unwrap : Formula.abstract term -> 'a term
            val e_true : Formula.boolean term
            val e_false : Formula.boolean term
            val e_int : int -> Formula.integer term
            val e_float : float -> Formula.real term
            val e_icst : string -> Formula.integer term
            val e_rcst : string -> Formula.real term
            val e_int64 : int64 -> Formula.integer term
            val e_ineg : Formula.integer term -> Formula.integer term
            val e_rneg : Formula.real term -> Formula.real term
            val e_iop :
              Formula.integer_op ->
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_rop :
              Formula.real_op ->
              Formula.real term -> Formula.real term -> Formula.real term
            val e_icmp :
              Formula.cmp_op ->
              Formula.integer term ->
              Formula.integer term -> Formula.boolean term
            val e_rcmp :
              Formula.cmp_op ->
              Formula.real term -> Formula.real term -> Formula.boolean term
            val p_icmp :
              Formula.cmp_op ->
              Formula.integer term -> Formula.integer term -> pred
            val p_rcmp :
              Formula.cmp_op ->
              Formula.real term -> Formula.real term -> pred
            val e_bnot : Formula.integer term -> Formula.integer term
            val e_band :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_bor :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_bxor :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_lshift :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val e_rshift :
              Formula.integer term ->
              Formula.integer term -> Formula.integer term
            val integer_of_real : Formula.real term -> Formula.integer term
            val real_of_integer : Formula.integer term -> Formula.real term
            val e_bool : Formula.boolean term -> Formula.integer term
            val e_not : Formula.boolean term -> Formula.boolean term
            val e_and :
              Formula.boolean term ->
              Formula.boolean term -> Formula.boolean term
            val e_or :
              Formula.boolean term ->
              Formula.boolean term -> Formula.boolean term
            val e_cond :
              Formula.boolean term -> 'a term -> 'a term -> 'a term
            val p_cond : Formula.boolean term -> pred -> pred -> pred
            val p_true : pred
            val p_false : pred
            val p_bool : Formula.boolean term -> 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 var = D.F.var
            type pool = D.F.pool
            val pool : unit -> pool
            val fresh : pool -> string -> Formula.kind -> var
            val freshen : pool -> var -> var
            val var : var -> 'a term
            val eq_var : var -> var -> bool
            val name_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_closed : 'a term -> bool
            val pred_closed : pred -> bool
            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 = D.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_term : Format.formatter -> 'a term -> unit
            val pp_pred : Format.formatter -> pred -> unit
            val pp_decl :
              Format.formatter -> pred Formula.declaration -> unit
            val pp_goal : Format.formatter -> string -> pred -> unit
          end
        module Model :
          sig
            module D :
              sig
                module F :
                  sig
                    type 'a term = 'D.F.term
                    type pred = D.F.pred
                    val e_int : int -> Formula.integer term
                    val e_call :
                      string ->
                      Formula.abstract term list -> Formula.abstract term
                    val p_call : string -> Formula.abstract term list -> pred
                    val wrap : 'a term -> Formula.abstract term
                    val unwrap : Formula.abstract term -> 'a term
                    val e_true : Formula.boolean term
                    val e_false : Formula.boolean term
                    val e_int : int -> Formula.integer term
                    val e_float : float -> Formula.real term
                    val e_icst : string -> Formula.integer term
                    val e_rcst : string -> Formula.real term
                    val e_int64 : int64 -> Formula.integer term
                    val e_ineg : Formula.integer term -> Formula.integer term
                    val e_rneg : Formula.real term -> Formula.real term
                    val e_iop :
                      Formula.integer_op ->
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_rop :
                      Formula.real_op ->
                      Formula.real term ->
                      Formula.real term -> Formula.real term
                    val e_icmp :
                      Formula.cmp_op ->
                      Formula.integer term ->
                      Formula.integer term -> Formula.boolean term
                    val e_rcmp :
                      Formula.cmp_op ->
                      Formula.real term ->
                      Formula.real term -> Formula.boolean term
                    val p_icmp :
                      Formula.cmp_op ->
                      Formula.integer term -> Formula.integer term -> pred
                    val p_rcmp :
                      Formula.cmp_op ->
                      Formula.real term -> Formula.real term -> pred
                    val e_bnot : Formula.integer term -> Formula.integer term
                    val e_band :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_bor :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_bxor :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_lshift :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_rshift :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val integer_of_real :
                      Formula.real term -> Formula.integer term
                    val real_of_integer :
                      Formula.integer term -> Formula.real term
                    val e_bool : Formula.boolean term -> Formula.integer term
                    val e_not : Formula.boolean term -> Formula.boolean term
                    val e_and :
                      Formula.boolean term ->
                      Formula.boolean term -> Formula.boolean term
                    val e_or :
                      Formula.boolean term ->
                      Formula.boolean term -> Formula.boolean term
                    val e_cond :
                      Formula.boolean term -> 'a term -> 'a term -> 'a term
                    val p_cond : Formula.boolean term -> pred -> pred -> pred
                    val p_true : pred
                    val p_false : pred
                    val p_bool : Formula.boolean term -> 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 var = D.F.var
                    type pool = D.F.pool
                    val pool : unit -> pool
                    val fresh : pool -> string -> Formula.kind -> var
                    val freshen : pool -> var -> var
                    val var : var -> 'a term
                    val eq_var : var -> var -> bool
                    val name_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_closed : 'a term -> bool
                    val pred_closed : pred -> bool
                    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 = D.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_term : Format.formatter -> 'a term -> unit
                    val pp_pred : Format.formatter -> pred -> unit
                    val pp_decl :
                      Format.formatter -> pred Formula.declaration -> unit
                    val pp_goal : Format.formatter -> string -> pred -> unit
                  end
                type format = Formula.m_format F.term
                type abstract = Formula.abstract F.term
                type integer = Formula.integer F.term
                type real = Formula.real F.term
                type boolean = Formula.boolean F.term
                type record = Formula.m_array F.term
                type urecord = Formula.m_array F.term
                type array = Formula.m_array F.term
                type set = Formula.m_set F.term
                type name = Formula.integer F.term
                type pointer = Formula.m_pointer F.term
                val pp_kind : Format.formatter -> Mdata.kind -> unit
                type interval =
                  D.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'D.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                val pp_interval : Format.formatter -> interval -> unit
                val e_app0 : string -> 'F.term
                val e_app1 : string -> 'F.term -> 'F.term
                val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
                val e_app3 :
                  string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
                val e_app4 :
                  string ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term
                val e_app5 :
                  string ->
                  'F.term ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term
                val p_app0 : string -> F.pred
                val p_app1 : string -> 'F.term -> F.pred
                val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                val p_app3 :
                  string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val p_app4 :
                  string ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val p_app5 :
                  string ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
                type context = D.context
                type bindings = D.bindings
                class type hint =
                  object
                    method capture : F.var list -> unit
                    method has_var : F.var list -> bool
                    method pretty : Format.formatter -> unit
                    method subst : F.var -> Formula.abstract F.term -> unit
                  end
                val closed : bindings
                val close : bindings -> F.pred -> F.pred
                val capture : hint list -> bindings -> unit
                val push :
                  string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
                val alpha : F.var -> F.var option
                val pool : unit -> F.pool
                val vkind_of_var : F.var -> Mdata.vkind
                val has_vars : F.var list -> F.pred -> bool
                type substitution = D.substitution
                val apply : substitution -> 'F.term -> 'F.term
                type havoc =
                  D.havoc =
                    Fresh of F.var
                  | Update of F.var *
                      (substitution -> Formula.abstract F.term)
                val havoc_static : havoc list -> F.pred -> F.pred
                val havoc_inductive : havoc list -> F.pred -> F.pred
                val clear : unit -> unit
                val on_clear : (unit -> unit) -> unit
                val fresh_name : string -> string -> string
                val add_declaration : F.pred Formula.declaration -> unit
                val iter :
                  Formula.section ->
                  (F.pred Formula.declaration -> unit) -> unit
                val iter_all : (F.pred Formula.declaration -> unit) -> unit
                val dummy : unit -> F.pred
                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 -> Log.source 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 -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
                  end
                module Register :
                  functor (D : Declarator->
                    sig
                      type t = D.t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                    end
                module Varinfo :
                  sig
                    type t = Cil_types.varinfo
                    module H :
                      sig
                        type key = D.Varinfo.H.key
                        type 'a t = 'D.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 -> Log.source 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 = D.Varaddr.H.key
                        type 'a t = 'D.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 -> Log.source 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 = D.Fieldinfo.H.key
                        type 'a t = 'D.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 -> Log.source 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 = D.Compinfo.H.key
                        type 'a t = 'D.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 -> Log.source 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 = D.Arrayinfo.H.key
                        type 'a t = 'D.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 -> Log.source 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 = D.Logicvar.H.key
                        type 'a t = 'D.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 -> Log.source option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module type Indexed =
                  sig
                    type t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Dindex :
                  functor (I : Identifiable->
                    sig
                      type t = I.t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                module Findex :
                  sig
                    type t = Cil_types.fieldinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Xindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Aindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Tindex :
                  sig
                    type t = Cil_types.compinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                val modulo : Ctypes.c_int -> integer -> integer
                val guard : Ctypes.c_int -> integer -> F.pred
                val i_convert :
                  Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                val round : Ctypes.c_float -> real -> real
                val f_guard : Ctypes.c_float -> real -> F.pred
                val f_convert :
                  Ctypes.c_float -> Ctypes.c_float -> real -> real
                val has_type : abstract -> Cil_types.logic_type -> F.pred
                val get_range_index : array -> interval -> abstract
                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 equal_pointer_bool : pointer -> pointer -> boolean
                val lt_pointer_bool : pointer -> pointer -> boolean
                val le_pointer_bool : pointer -> pointer -> boolean
                val lt_pointer : pointer -> pointer -> F.pred
                val le_pointer : pointer -> pointer -> F.pred
                val minus_pointer : pointer -> pointer -> integer
                val is_null : pointer -> boolean
                val null : pointer
                val tau_of_object : Ctypes.c_object -> Formula.tau
                val tau_of_ctype : Cil_types.typ -> Formula.tau
                val int_format : format
                val real_format : format
                val pointer_format : format
                val record_format : format
                val urecord_format : format
                val array_format : format -> format
                val format_of_object : Ctypes.c_object -> format
                val decode : format -> abstract -> 'F.term
                val encode : format -> 'F.term -> abstract
                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
                val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
                val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
                val eq_record :
                  Cil_types.compinfo -> record -> record -> F.pred
              end
            module A :
              sig
                module D :
                  sig
                    module F :
                      sig
                        type 'a term = 'D.F.term
                        type pred = D.F.pred
                        val e_int : int -> Formula.integer term
                        val e_call :
                          string ->
                          Formula.abstract term list -> Formula.abstract term
                        val p_call :
                          string -> Formula.abstract term list -> pred
                        val wrap : 'a term -> Formula.abstract term
                        val unwrap : Formula.abstract term -> 'a term
                        val e_true : Formula.boolean term
                        val e_false : Formula.boolean term
                        val e_int : int -> Formula.integer term
                        val e_float : float -> Formula.real term
                        val e_icst : string -> Formula.integer term
                        val e_rcst : string -> Formula.real term
                        val e_int64 : int64 -> Formula.integer term
                        val e_ineg :
                          Formula.integer term -> Formula.integer term
                        val e_rneg : Formula.real term -> Formula.real term
                        val e_iop :
                          Formula.integer_op ->
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_rop :
                          Formula.real_op ->
                          Formula.real term ->
                          Formula.real term -> Formula.real term
                        val e_icmp :
                          Formula.cmp_op ->
                          Formula.integer term ->
                          Formula.integer term -> Formula.boolean term
                        val e_rcmp :
                          Formula.cmp_op ->
                          Formula.real term ->
                          Formula.real term -> Formula.boolean term
                        val p_icmp :
                          Formula.cmp_op ->
                          Formula.integer term ->
                          Formula.integer term -> pred
                        val p_rcmp :
                          Formula.cmp_op ->
                          Formula.real term -> Formula.real term -> pred
                        val e_bnot :
                          Formula.integer term -> Formula.integer term
                        val e_band :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_bor :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_bxor :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_lshift :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_rshift :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val integer_of_real :
                          Formula.real term -> Formula.integer term
                        val real_of_integer :
                          Formula.integer term -> Formula.real term
                        val e_bool :
                          Formula.boolean term -> Formula.integer term
                        val e_not :
                          Formula.boolean term -> Formula.boolean term
                        val e_and :
                          Formula.boolean term ->
                          Formula.boolean term -> Formula.boolean term
                        val e_or :
                          Formula.boolean term ->
                          Formula.boolean term -> Formula.boolean term
                        val e_cond :
                          Formula.boolean term ->
                          'a term -> 'a term -> 'a term
                        val p_cond :
                          Formula.boolean term -> pred -> pred -> pred
                        val p_true : pred
                        val p_false : pred
                        val p_bool : Formula.boolean term -> 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 var = D.F.var
                        type pool = D.F.pool
                        val pool : unit -> pool
                        val fresh : pool -> string -> Formula.kind -> var
                        val freshen : pool -> var -> var
                        val var : var -> 'a term
                        val eq_var : var -> var -> bool
                        val name_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_closed : 'a term -> bool
                        val pred_closed : pred -> bool
                        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 = D.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_term : Format.formatter -> 'a term -> unit
                        val pp_pred : Format.formatter -> pred -> unit
                        val pp_decl :
                          Format.formatter ->
                          pred Formula.declaration -> unit
                        val pp_goal :
                          Format.formatter -> string -> pred -> unit
                      end
                    type format = Formula.m_format F.term
                    type abstract = Formula.abstract F.term
                    type integer = Formula.integer F.term
                    type real = Formula.real F.term
                    type boolean = Formula.boolean F.term
                    type record = Formula.m_array F.term
                    type urecord = Formula.m_array F.term
                    type array = Formula.m_array F.term
                    type set = Formula.m_set F.term
                    type name = Formula.integer F.term
                    type pointer = Formula.m_pointer F.term
                    val pp_kind : Format.formatter -> Mdata.kind -> unit
                    type interval =
                      D.interval = {
                      inf : integer option;
                      sup : integer option;
                    }
                    type 'a assigned =
                      'D.assigned =
                        Aloc of Ctypes.c_object * 'a
                      | Arange of Ctypes.c_object * 'a * interval
                    val pp_interval : Format.formatter -> interval -> unit
                    val e_app0 : string -> 'F.term
                    val e_app1 : string -> 'F.term -> 'F.term
                    val e_app2 :
                      string -> 'F.term -> 'F.term -> 'F.term
                    val e_app3 :
                      string ->
                      'F.term -> 'F.term -> 'F.term -> 'F.term
                    val e_app4 :
                      string ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> 'F.term
                    val e_app5 :
                      string ->
                      'F.term ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> 'F.term
                    val p_app0 : string -> F.pred
                    val p_app1 : string -> 'F.term -> F.pred
                    val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                    val p_app3 :
                      string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                    val p_app4 :
                      string ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> F.pred
                    val p_app5 :
                      string ->
                      'F.term ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> F.pred
                    val tau_of_logic_type :
                      Cil_types.logic_type -> Formula.tau
                    type context = D.context
                    type bindings = D.bindings
                    class type hint =
                      object
                        method capture : F.var list -> unit
                        method has_var : F.var list -> bool
                        method pretty : Format.formatter -> unit
                        method subst :
                          F.var -> Formula.abstract F.term -> unit
                      end
                    val closed : bindings
                    val close : bindings -> F.pred -> F.pred
                    val capture : hint list -> bindings -> unit
                    val push :
                      string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
                    val alpha : F.var -> F.var option
                    val pool : unit -> F.pool
                    val vkind_of_var : F.var -> Mdata.vkind
                    val has_vars : F.var list -> F.pred -> bool
                    type substitution = D.substitution
                    val apply : substitution -> 'F.term -> 'F.term
                    type havoc =
                      D.havoc =
                        Fresh of F.var
                      | Update of F.var *
                          (substitution -> Formula.abstract F.term)
                    val havoc_static : havoc list -> F.pred -> F.pred
                    val havoc_inductive : havoc list -> F.pred -> F.pred
                    val clear : unit -> unit
                    val on_clear : (unit -> unit) -> unit
                    val fresh_name : string -> string -> string
                    val add_declaration : F.pred Formula.declaration -> unit
                    val iter :
                      Formula.section ->
                      (F.pred Formula.declaration -> unit) -> unit
                    val iter_all :
                      (F.pred Formula.declaration -> unit) -> unit
                    val dummy : unit -> F.pred
                    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 -> Log.source 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 -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
                      end
                    module Register :
                      functor (D : Declarator->
                        sig
                          type t = D.t
                          val define : t -> unit
                          val get_definition :
                            t -> F.pred Formula.declaration
                          val on_definition :
                            (t -> F.pred Formula.declaration -> unit) -> unit
                        end
                    module Varinfo :
                      sig
                        type t = Cil_types.varinfo
                        module H :
                          sig
                            type key = D.Varinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Varaddr.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Fieldinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Compinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Arrayinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Logicvar.H.key
                            type 'a t = 'D.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 -> Log.source option
                        val pp_title : Format.formatter -> t -> unit
                        val pp_descr : Format.formatter -> t -> unit
                      end
                    module type Indexed =
                      sig
                        type t
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Dindex :
                      functor (I : Identifiable->
                        sig
                          type t = I.t
                          val define : t -> unit
                          val get_definition :
                            t -> F.pred Formula.declaration
                          val on_definition :
                            (t -> F.pred Formula.declaration -> unit) -> unit
                          val get_ind : t -> integer
                        end
                    module Findex :
                      sig
                        type t = Cil_types.fieldinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Xindex :
                      sig
                        type t = Cil_types.varinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Aindex :
                      sig
                        type t = Cil_types.varinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Tindex :
                      sig
                        type t = Cil_types.compinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    val modulo : Ctypes.c_int -> integer -> integer
                    val guard : Ctypes.c_int -> integer -> F.pred
                    val i_convert :
                      Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                    val round : Ctypes.c_float -> real -> real
                    val f_guard : Ctypes.c_float -> real -> F.pred
                    val f_convert :
                      Ctypes.c_float -> Ctypes.c_float -> real -> real
                    val has_type : abstract -> Cil_types.logic_type -> F.pred
                    val get_range_index : array -> interval -> abstract
                    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 equal_pointer_bool : pointer -> pointer -> boolean
                    val lt_pointer_bool : pointer -> pointer -> boolean
                    val le_pointer_bool : pointer -> pointer -> boolean
                    val lt_pointer : pointer -> pointer -> F.pred
                    val le_pointer : pointer -> pointer -> F.pred
                    val minus_pointer : pointer -> pointer -> integer
                    val is_null : pointer -> boolean
                    val null : pointer
                    val tau_of_object : Ctypes.c_object -> Formula.tau
                    val tau_of_ctype : Cil_types.typ -> Formula.tau
                    val int_format : format
                    val real_format : format
                    val pointer_format : format
                    val record_format : format
                    val urecord_format : format
                    val array_format : format -> format
                    val format_of_object : Ctypes.c_object -> format
                    val decode : format -> abstract -> 'F.term
                    val encode : format -> 'F.term -> abstract
                    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
                    val equal :
                      Ctypes.c_object -> abstract -> abstract -> F.pred
                    val eq_array :
                      Ctypes.arrayinfo -> array -> array -> F.pred
                    val eq_record :
                      Cil_types.compinfo -> record -> record -> F.pred
                  end
                val i_neg : Ctypes.c_int -> D.integer -> D.integer
                val i_op :
                  Ctypes.c_int ->
                  Formula.integer_op -> D.integer -> D.integer -> D.integer
                val i_cmp :
                  Ctypes.c_int ->
                  Formula.cmp_op -> D.integer -> D.integer -> D.boolean
                val bits_not : Ctypes.c_int -> D.integer -> D.integer
                val bits_and :
                  Ctypes.c_int -> D.integer -> D.integer -> D.integer
                val bits_or :
                  Ctypes.c_int -> D.integer -> D.integer -> D.integer
                val bits_xor :
                  Ctypes.c_int -> D.integer -> D.integer -> D.integer
                val bits_lshift :
                  Ctypes.c_int -> D.integer -> D.integer -> D.integer
                val bits_rshift :
                  Ctypes.c_int -> D.integer -> D.integer -> D.integer
              end
            module R :
              sig
                module D :
                  sig
                    module F :
                      sig
                        type 'a term = 'D.F.term
                        type pred = D.F.pred
                        val e_int : int -> Formula.integer term
                        val e_call :
                          string ->
                          Formula.abstract term list -> Formula.abstract term
                        val p_call :
                          string -> Formula.abstract term list -> pred
                        val wrap : 'a term -> Formula.abstract term
                        val unwrap : Formula.abstract term -> 'a term
                        val e_true : Formula.boolean term
                        val e_false : Formula.boolean term
                        val e_int : int -> Formula.integer term
                        val e_float : float -> Formula.real term
                        val e_icst : string -> Formula.integer term
                        val e_rcst : string -> Formula.real term
                        val e_int64 : int64 -> Formula.integer term
                        val e_ineg :
                          Formula.integer term -> Formula.integer term
                        val e_rneg : Formula.real term -> Formula.real term
                        val e_iop :
                          Formula.integer_op ->
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_rop :
                          Formula.real_op ->
                          Formula.real term ->
                          Formula.real term -> Formula.real term
                        val e_icmp :
                          Formula.cmp_op ->
                          Formula.integer term ->
                          Formula.integer term -> Formula.boolean term
                        val e_rcmp :
                          Formula.cmp_op ->
                          Formula.real term ->
                          Formula.real term -> Formula.boolean term
                        val p_icmp :
                          Formula.cmp_op ->
                          Formula.integer term ->
                          Formula.integer term -> pred
                        val p_rcmp :
                          Formula.cmp_op ->
                          Formula.real term -> Formula.real term -> pred
                        val e_bnot :
                          Formula.integer term -> Formula.integer term
                        val e_band :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_bor :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_bxor :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_lshift :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val e_rshift :
                          Formula.integer term ->
                          Formula.integer term -> Formula.integer term
                        val integer_of_real :
                          Formula.real term -> Formula.integer term
                        val real_of_integer :
                          Formula.integer term -> Formula.real term
                        val e_bool :
                          Formula.boolean term -> Formula.integer term
                        val e_not :
                          Formula.boolean term -> Formula.boolean term
                        val e_and :
                          Formula.boolean term ->
                          Formula.boolean term -> Formula.boolean term
                        val e_or :
                          Formula.boolean term ->
                          Formula.boolean term -> Formula.boolean term
                        val e_cond :
                          Formula.boolean term ->
                          'a term -> 'a term -> 'a term
                        val p_cond :
                          Formula.boolean term -> pred -> pred -> pred
                        val p_true : pred
                        val p_false : pred
                        val p_bool : Formula.boolean term -> 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 var = D.F.var
                        type pool = D.F.pool
                        val pool : unit -> pool
                        val fresh : pool -> string -> Formula.kind -> var
                        val freshen : pool -> var -> var
                        val var : var -> 'a term
                        val eq_var : var -> var -> bool
                        val name_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_closed : 'a term -> bool
                        val pred_closed : pred -> bool
                        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 = D.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_term : Format.formatter -> 'a term -> unit
                        val pp_pred : Format.formatter -> pred -> unit
                        val pp_decl :
                          Format.formatter ->
                          pred Formula.declaration -> unit
                        val pp_goal :
                          Format.formatter -> string -> pred -> unit
                      end
                    type format = Formula.m_format F.term
                    type abstract = Formula.abstract F.term
                    type integer = Formula.integer F.term
                    type real = Formula.real F.term
                    type boolean = Formula.boolean F.term
                    type record = Formula.m_array F.term
                    type urecord = Formula.m_array F.term
                    type array = Formula.m_array F.term
                    type set = Formula.m_set F.term
                    type name = Formula.integer F.term
                    type pointer = Formula.m_pointer F.term
                    val pp_kind : Format.formatter -> Mdata.kind -> unit
                    type interval =
                      D.interval = {
                      inf : integer option;
                      sup : integer option;
                    }
                    type 'a assigned =
                      'D.assigned =
                        Aloc of Ctypes.c_object * 'a
                      | Arange of Ctypes.c_object * 'a * interval
                    val pp_interval : Format.formatter -> interval -> unit
                    val e_app0 : string -> 'F.term
                    val e_app1 : string -> 'F.term -> 'F.term
                    val e_app2 :
                      string -> 'F.term -> 'F.term -> 'F.term
                    val e_app3 :
                      string ->
                      'F.term -> 'F.term -> 'F.term -> 'F.term
                    val e_app4 :
                      string ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> 'F.term
                    val e_app5 :
                      string ->
                      'F.term ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> 'F.term
                    val p_app0 : string -> F.pred
                    val p_app1 : string -> 'F.term -> F.pred
                    val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                    val p_app3 :
                      string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                    val p_app4 :
                      string ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> F.pred
                    val p_app5 :
                      string ->
                      'F.term ->
                      'F.term ->
                      'F.term -> 'F.term -> 'F.term -> F.pred
                    val tau_of_logic_type :
                      Cil_types.logic_type -> Formula.tau
                    type context = D.context
                    type bindings = D.bindings
                    class type hint =
                      object
                        method capture : F.var list -> unit
                        method has_var : F.var list -> bool
                        method pretty : Format.formatter -> unit
                        method subst :
                          F.var -> Formula.abstract F.term -> unit
                      end
                    val closed : bindings
                    val close : bindings -> F.pred -> F.pred
                    val capture : hint list -> bindings -> unit
                    val push :
                      string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
                    val alpha : F.var -> F.var option
                    val pool : unit -> F.pool
                    val vkind_of_var : F.var -> Mdata.vkind
                    val has_vars : F.var list -> F.pred -> bool
                    type substitution = D.substitution
                    val apply : substitution -> 'F.term -> 'F.term
                    type havoc =
                      D.havoc =
                        Fresh of F.var
                      | Update of F.var *
                          (substitution -> Formula.abstract F.term)
                    val havoc_static : havoc list -> F.pred -> F.pred
                    val havoc_inductive : havoc list -> F.pred -> F.pred
                    val clear : unit -> unit
                    val on_clear : (unit -> unit) -> unit
                    val fresh_name : string -> string -> string
                    val add_declaration : F.pred Formula.declaration -> unit
                    val iter :
                      Formula.section ->
                      (F.pred Formula.declaration -> unit) -> unit
                    val iter_all :
                      (F.pred Formula.declaration -> unit) -> unit
                    val dummy : unit -> F.pred
                    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 -> Log.source 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 -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
                      end
                    module Register :
                      functor (D : Declarator->
                        sig
                          type t = D.t
                          val define : t -> unit
                          val get_definition :
                            t -> F.pred Formula.declaration
                          val on_definition :
                            (t -> F.pred Formula.declaration -> unit) -> unit
                        end
                    module Varinfo :
                      sig
                        type t = Cil_types.varinfo
                        module H :
                          sig
                            type key = D.Varinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Varaddr.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Fieldinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Compinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Arrayinfo.H.key
                            type 'a t = 'D.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 -> Log.source 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 = D.Logicvar.H.key
                            type 'a t = 'D.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 -> Log.source option
                        val pp_title : Format.formatter -> t -> unit
                        val pp_descr : Format.formatter -> t -> unit
                      end
                    module type Indexed =
                      sig
                        type t
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Dindex :
                      functor (I : Identifiable->
                        sig
                          type t = I.t
                          val define : t -> unit
                          val get_definition :
                            t -> F.pred Formula.declaration
                          val on_definition :
                            (t -> F.pred Formula.declaration -> unit) -> unit
                          val get_ind : t -> integer
                        end
                    module Findex :
                      sig
                        type t = Cil_types.fieldinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Xindex :
                      sig
                        type t = Cil_types.varinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Aindex :
                      sig
                        type t = Cil_types.varinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Tindex :
                      sig
                        type t = Cil_types.compinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    val modulo : Ctypes.c_int -> integer -> integer
                    val guard : Ctypes.c_int -> integer -> F.pred
                    val i_convert :
                      Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                    val round : Ctypes.c_float -> real -> real
                    val f_guard : Ctypes.c_float -> real -> F.pred
                    val f_convert :
                      Ctypes.c_float -> Ctypes.c_float -> real -> real
                    val has_type : abstract -> Cil_types.logic_type -> F.pred
                    val get_range_index : array -> interval -> abstract
                    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 equal_pointer_bool : pointer -> pointer -> boolean
                    val lt_pointer_bool : pointer -> pointer -> boolean
                    val le_pointer_bool : pointer -> pointer -> boolean
                    val lt_pointer : pointer -> pointer -> F.pred
                    val le_pointer : pointer -> pointer -> F.pred
                    val minus_pointer : pointer -> pointer -> integer
                    val is_null : pointer -> boolean
                    val null : pointer
                    val tau_of_object : Ctypes.c_object -> Formula.tau
                    val tau_of_ctype : Cil_types.typ -> Formula.tau
                    val int_format : format
                    val real_format : format
                    val pointer_format : format
                    val record_format : format
                    val urecord_format : format
                    val array_format : format -> format
                    val format_of_object : Ctypes.c_object -> format
                    val decode : format -> abstract -> 'F.term
                    val encode : format -> 'F.term -> abstract
                    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
                    val equal :
                      Ctypes.c_object -> abstract -> abstract -> F.pred
                    val eq_array :
                      Ctypes.arrayinfo -> array -> array -> F.pred
                    val eq_record :
                      Cil_types.compinfo -> record -> record -> F.pred
                  end
                val f_neg : Ctypes.c_float -> D.real -> D.real
                val f_op :
                  Ctypes.c_float ->
                  Formula.real_op -> D.real -> D.real -> D.real
                val f_cmp :
                  Ctypes.c_float ->
                  Formula.cmp_op -> D.real -> D.real -> D.boolean
              end
            type epath =
                Pfield of Cil_types.fieldinfo
              | Pidx of Hoare_mem.Create.Model.D.integer
            type loc =
                L0addr of Cil_types.varinfo
              | L0depl of Hoare_mem.Create.Model.loc *
                  Hoare_mem.Create.Model.epath
              | L0ptr of Hoare_mem.Create.Model.D.pointer
              | L0shift of Hoare_mem.Create.Model.loc *
                  Hoare_mem.Create.Model.D.integer
            val pointer_of_loc :
              Hoare_mem.Create.Model.loc -> Hoare_mem.Create.Model.D.pointer
            val loc_of_pointer :
              '->
              Hoare_mem.Create.Model.D.pointer -> Hoare_mem.Create.Model.loc
            val pp_loc :
              Format.formatter -> Hoare_mem.Create.Model.loc -> unit
            val pp_epath :
              Format.formatter -> Hoare_mem.Create.Model.epath -> unit
            val cast_loc_to_int : '-> '-> '-> 'd
            val cast_int_to_loc : '-> '-> '-> 'd
          end
        val cast_loc_to_loc : Cil_types.typ -> Cil_types.typ -> '-> 'b
        module D :
          sig
            module F :
              sig
                type 'a term = 'Model.D.F.term
                type pred = Model.D.F.pred
                val e_int : int -> Formula.integer term
                val e_call :
                  string ->
                  Formula.abstract term list -> Formula.abstract term
                val p_call : string -> Formula.abstract term list -> pred
                val wrap : 'a term -> Formula.abstract term
                val unwrap : Formula.abstract term -> 'a term
                val e_true : Formula.boolean term
                val e_false : Formula.boolean term
                val e_int : int -> Formula.integer term
                val e_float : float -> Formula.real term
                val e_icst : string -> Formula.integer term
                val e_rcst : string -> Formula.real term
                val e_int64 : int64 -> Formula.integer term
                val e_ineg : Formula.integer term -> Formula.integer term
                val e_rneg : Formula.real term -> Formula.real term
                val e_iop :
                  Formula.integer_op ->
                  Formula.integer term ->
                  Formula.integer term -> Formula.integer term
                val e_rop :
                  Formula.real_op ->
                  Formula.real term -> Formula.real term -> Formula.real term
                val e_icmp :
                  Formula.cmp_op ->
                  Formula.integer term ->
                  Formula.integer term -> Formula.boolean term
                val e_rcmp :
                  Formula.cmp_op ->
                  Formula.real term ->
                  Formula.real term -> Formula.boolean term
                val p_icmp :
                  Formula.cmp_op ->
                  Formula.integer term -> Formula.integer term -> pred
                val p_rcmp :
                  Formula.cmp_op ->
                  Formula.real term -> Formula.real term -> pred
                val e_bnot : Formula.integer term -> Formula.integer term
                val e_band :
                  Formula.integer term ->
                  Formula.integer term -> Formula.integer term
                val e_bor :
                  Formula.integer term ->
                  Formula.integer term -> Formula.integer term
                val e_bxor :
                  Formula.integer term ->
                  Formula.integer term -> Formula.integer term
                val e_lshift :
                  Formula.integer term ->
                  Formula.integer term -> Formula.integer term
                val e_rshift :
                  Formula.integer term ->
                  Formula.integer term -> Formula.integer term
                val integer_of_real :
                  Formula.real term -> Formula.integer term
                val real_of_integer :
                  Formula.integer term -> Formula.real term
                val e_bool : Formula.boolean term -> Formula.integer term
                val e_not : Formula.boolean term -> Formula.boolean term
                val e_and :
                  Formula.boolean term ->
                  Formula.boolean term -> Formula.boolean term
                val e_or :
                  Formula.boolean term ->
                  Formula.boolean term -> Formula.boolean term
                val e_cond :
                  Formula.boolean term -> 'a term -> 'a term -> 'a term
                val p_cond : Formula.boolean term -> pred -> pred -> pred
                val p_true : pred
                val p_false : pred
                val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
                type pool = Model.D.F.pool
                val pool : unit -> pool
                val fresh : pool -> string -> Formula.kind -> var
                val freshen : pool -> var -> var
                val var : var -> 'a term
                val eq_var : var -> var -> bool
                val name_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_closed : 'a term -> bool
                val pred_closed : pred -> bool
                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.D.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_term : Format.formatter -> 'a term -> unit
                val pp_pred : Format.formatter -> pred -> unit
                val pp_decl :
                  Format.formatter -> pred Formula.declaration -> unit
                val pp_goal : Format.formatter -> string -> pred -> unit
              end
            type format = Formula.m_format F.term
            type abstract = Formula.abstract F.term
            type integer = Formula.integer F.term
            type real = Formula.real F.term
            type boolean = Formula.boolean F.term
            type record = Formula.m_array F.term
            type urecord = Formula.m_array F.term
            type array = Formula.m_array F.term
            type set = Formula.m_set F.term
            type name = Formula.integer F.term
            type pointer = Formula.m_pointer F.term
            val pp_kind : Format.formatter -> Mdata.kind -> unit
            type interval =
              Model.D.interval = {
              inf : integer option;
              sup : integer option;
            }
            type 'a assigned =
              'Model.D.assigned =
                Aloc of Ctypes.c_object * 'a
              | Arange of Ctypes.c_object * 'a * interval
            val pp_interval : Format.formatter -> interval -> unit
            val e_app0 : string -> 'F.term
            val e_app1 : string -> 'F.term -> 'F.term
            val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
            val e_app3 :
              string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
            val e_app4 :
              string ->
              'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
            val e_app5 :
              string ->
              'F.term ->
              'F.term -> 'F.term -> 'F.term -> 'F.term -> 'F.term
            val p_app0 : string -> F.pred
            val p_app1 : string -> 'F.term -> F.pred
            val p_app2 : string -> 'F.term -> 'F.term -> F.pred
            val p_app3 :
              string -> 'F.term -> 'F.term -> 'F.term -> F.pred
            val p_app4 :
              string ->
              'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
            val p_app5 :
              string ->
              'F.term ->
              'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
            val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
            type context = Model.D.context
            type bindings = Model.D.bindings
            class type hint =
              object
                method capture : F.var list -> unit
                method has_var : F.var list -> bool
                method pretty : Format.formatter -> unit
                method subst : F.var -> Formula.abstract F.term -> unit
              end
            val closed : bindings
            val close : bindings -> F.pred -> F.pred
            val capture : hint list -> bindings -> unit
            val push : string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
            val alpha : F.var -> F.var option
            val pool : unit -> F.pool
            val vkind_of_var : F.var -> Mdata.vkind
            val has_vars : F.var list -> F.pred -> bool
            type substitution = Model.D.substitution
            val apply : substitution -> 'F.term -> 'F.term
            type havoc =
              Model.D.havoc =
                Fresh of F.var
              | Update of F.var * (substitution -> Formula.abstract F.term)
            val havoc_static : havoc list -> F.pred -> F.pred
            val havoc_inductive : havoc list -> F.pred -> F.pred
            val clear : unit -> unit
            val on_clear : (unit -> unit) -> unit
            val fresh_name : string -> string -> string
            val add_declaration : F.pred Formula.declaration -> unit
            val iter :
              Formula.section -> (F.pred Formula.declaration -> unit) -> unit
            val iter_all : (F.pred Formula.declaration -> unit) -> unit
            val dummy : unit -> F.pred
            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 -> Log.source 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 -> F.pred Formula.declaration
                val on_definition :
                  (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
              end
            module Register :
              functor (D : Declarator->
                sig
                  type t = D.t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                end
            module Varinfo :
              sig
                type t = Cil_types.varinfo
                module H :
                  sig
                    type key = Model.D.Varinfo.H.key
                    type 'a t = 'Model.D.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 -> Log.source 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.D.Varaddr.H.key
                    type 'a t = 'Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
                    type 'a t = 'Model.D.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 -> Log.source 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.D.Compinfo.H.key
                    type 'a t = 'Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
                    type 'a t = 'Model.D.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 -> Log.source 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.D.Logicvar.H.key
                    type 'a t = 'Model.D.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 -> Log.source option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module type Indexed =
              sig
                type t
                val define : t -> unit
                val get_definition : t -> F.pred Formula.declaration
                val on_definition :
                  (t -> F.pred Formula.declaration -> unit) -> unit
                val get_ind : t -> integer
              end
            module Dindex :
              functor (I : Identifiable->
                sig
                  type t = I.t
                  val define : t -> unit
                  val get_definition : t -> F.pred Formula.declaration
                  val on_definition :
                    (t -> F.pred Formula.declaration -> unit) -> unit
                  val get_ind : t -> integer
                end
            module Findex :
              sig
                type t = Cil_types.fieldinfo
                val define : t -> unit
                val get_definition : t -> F.pred Formula.declaration
                val on_definition :
                  (t -> F.pred Formula.declaration -> unit) -> unit
                val get_ind : t -> integer
              end
            module Xindex :
              sig
                type t = Cil_types.varinfo
                val define : t -> unit
                val get_definition : t -> F.pred Formula.declaration
                val on_definition :
                  (t -> F.pred Formula.declaration -> unit) -> unit
                val get_ind : t -> integer
              end
            module Aindex :
              sig
                type t = Cil_types.varinfo
                val define : t -> unit
                val get_definition : t -> F.pred Formula.declaration
                val on_definition :
                  (t -> F.pred Formula.declaration -> unit) -> unit
                val get_ind : t -> integer
              end
            module Tindex :
              sig
                type t = Cil_types.compinfo
                val define : t -> unit
                val get_definition : t -> F.pred Formula.declaration
                val on_definition :
                  (t -> F.pred Formula.declaration -> unit) -> unit
                val get_ind : t -> integer
              end
            val modulo : Ctypes.c_int -> integer -> integer
            val guard : Ctypes.c_int -> integer -> F.pred
            val i_convert :
              Ctypes.c_int -> Ctypes.c_int -> integer -> integer
            val round : Ctypes.c_float -> real -> real
            val f_guard : Ctypes.c_float -> real -> F.pred
            val f_convert : Ctypes.c_float -> Ctypes.c_float -> real -> real
            val has_type : abstract -> Cil_types.logic_type -> F.pred
            val get_range_index : array -> interval -> abstract
            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 equal_pointer_bool : pointer -> pointer -> boolean
            val lt_pointer_bool : pointer -> pointer -> boolean
            val le_pointer_bool : pointer -> pointer -> boolean
            val lt_pointer : pointer -> pointer -> F.pred
            val le_pointer : pointer -> pointer -> F.pred
            val minus_pointer : pointer -> pointer -> integer
            val is_null : pointer -> boolean
            val null : pointer
            val tau_of_object : Ctypes.c_object -> Formula.tau
            val tau_of_ctype : Cil_types.typ -> Formula.tau
            val int_format : format
            val real_format : format
            val pointer_format : format
            val record_format : format
            val urecord_format : format
            val array_format : format -> format
            val format_of_object : Ctypes.c_object -> format
            val decode : format -> abstract -> 'F.term
            val encode : format -> 'F.term -> abstract
            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
            val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
            val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
            val eq_record : Cil_types.compinfo -> record -> record -> F.pred
          end
        module A :
          sig
            module D :
              sig
                module F :
                  sig
                    type 'a term = 'Model.D.F.term
                    type pred = Model.D.F.pred
                    val e_int : int -> Formula.integer term
                    val e_call :
                      string ->
                      Formula.abstract term list -> Formula.abstract term
                    val p_call : string -> Formula.abstract term list -> pred
                    val wrap : 'a term -> Formula.abstract term
                    val unwrap : Formula.abstract term -> 'a term
                    val e_true : Formula.boolean term
                    val e_false : Formula.boolean term
                    val e_int : int -> Formula.integer term
                    val e_float : float -> Formula.real term
                    val e_icst : string -> Formula.integer term
                    val e_rcst : string -> Formula.real term
                    val e_int64 : int64 -> Formula.integer term
                    val e_ineg : Formula.integer term -> Formula.integer term
                    val e_rneg : Formula.real term -> Formula.real term
                    val e_iop :
                      Formula.integer_op ->
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_rop :
                      Formula.real_op ->
                      Formula.real term ->
                      Formula.real term -> Formula.real term
                    val e_icmp :
                      Formula.cmp_op ->
                      Formula.integer term ->
                      Formula.integer term -> Formula.boolean term
                    val e_rcmp :
                      Formula.cmp_op ->
                      Formula.real term ->
                      Formula.real term -> Formula.boolean term
                    val p_icmp :
                      Formula.cmp_op ->
                      Formula.integer term -> Formula.integer term -> pred
                    val p_rcmp :
                      Formula.cmp_op ->
                      Formula.real term -> Formula.real term -> pred
                    val e_bnot : Formula.integer term -> Formula.integer term
                    val e_band :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_bor :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_bxor :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_lshift :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_rshift :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val integer_of_real :
                      Formula.real term -> Formula.integer term
                    val real_of_integer :
                      Formula.integer term -> Formula.real term
                    val e_bool : Formula.boolean term -> Formula.integer term
                    val e_not : Formula.boolean term -> Formula.boolean term
                    val e_and :
                      Formula.boolean term ->
                      Formula.boolean term -> Formula.boolean term
                    val e_or :
                      Formula.boolean term ->
                      Formula.boolean term -> Formula.boolean term
                    val e_cond :
                      Formula.boolean term -> 'a term -> 'a term -> 'a term
                    val p_cond : Formula.boolean term -> pred -> pred -> pred
                    val p_true : pred
                    val p_false : pred
                    val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
                    type pool = Model.D.F.pool
                    val pool : unit -> pool
                    val fresh : pool -> string -> Formula.kind -> var
                    val freshen : pool -> var -> var
                    val var : var -> 'a term
                    val eq_var : var -> var -> bool
                    val name_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_closed : 'a term -> bool
                    val pred_closed : pred -> bool
                    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.D.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_term : Format.formatter -> 'a term -> unit
                    val pp_pred : Format.formatter -> pred -> unit
                    val pp_decl :
                      Format.formatter -> pred Formula.declaration -> unit
                    val pp_goal : Format.formatter -> string -> pred -> unit
                  end
                type format = Formula.m_format F.term
                type abstract = Formula.abstract F.term
                type integer = Formula.integer F.term
                type real = Formula.real F.term
                type boolean = Formula.boolean F.term
                type record = Formula.m_array F.term
                type urecord = Formula.m_array F.term
                type array = Formula.m_array F.term
                type set = Formula.m_set F.term
                type name = Formula.integer F.term
                type pointer = Formula.m_pointer F.term
                val pp_kind : Format.formatter -> Mdata.kind -> unit
                type interval =
                  Model.D.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'Model.D.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                val pp_interval : Format.formatter -> interval -> unit
                val e_app0 : string -> 'F.term
                val e_app1 : string -> 'F.term -> 'F.term
                val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
                val e_app3 :
                  string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
                val e_app4 :
                  string ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term
                val e_app5 :
                  string ->
                  'F.term ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term
                val p_app0 : string -> F.pred
                val p_app1 : string -> 'F.term -> F.pred
                val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                val p_app3 :
                  string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val p_app4 :
                  string ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val p_app5 :
                  string ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
                type context = Model.D.context
                type bindings = Model.D.bindings
                class type hint =
                  object
                    method capture : F.var list -> unit
                    method has_var : F.var list -> bool
                    method pretty : Format.formatter -> unit
                    method subst : F.var -> Formula.abstract F.term -> unit
                  end
                val closed : bindings
                val close : bindings -> F.pred -> F.pred
                val capture : hint list -> bindings -> unit
                val push :
                  string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
                val alpha : F.var -> F.var option
                val pool : unit -> F.pool
                val vkind_of_var : F.var -> Mdata.vkind
                val has_vars : F.var list -> F.pred -> bool
                type substitution = Model.D.substitution
                val apply : substitution -> 'F.term -> 'F.term
                type havoc =
                  Model.D.havoc =
                    Fresh of F.var
                  | Update of F.var *
                      (substitution -> Formula.abstract F.term)
                val havoc_static : havoc list -> F.pred -> F.pred
                val havoc_inductive : havoc list -> F.pred -> F.pred
                val clear : unit -> unit
                val on_clear : (unit -> unit) -> unit
                val fresh_name : string -> string -> string
                val add_declaration : F.pred Formula.declaration -> unit
                val iter :
                  Formula.section ->
                  (F.pred Formula.declaration -> unit) -> unit
                val iter_all : (F.pred Formula.declaration -> unit) -> unit
                val dummy : unit -> F.pred
                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 -> Log.source 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 -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
                  end
                module Register :
                  functor (D : Declarator->
                    sig
                      type t = D.t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                    end
                module Varinfo :
                  sig
                    type t = Cil_types.varinfo
                    module H :
                      sig
                        type key = Model.D.Varinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Varaddr.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Compinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Logicvar.H.key
                        type 'a t = 'Model.D.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 -> Log.source option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module type Indexed =
                  sig
                    type t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Dindex :
                  functor (I : Identifiable->
                    sig
                      type t = I.t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                module Findex :
                  sig
                    type t = Cil_types.fieldinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Xindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Aindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Tindex :
                  sig
                    type t = Cil_types.compinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                val modulo : Ctypes.c_int -> integer -> integer
                val guard : Ctypes.c_int -> integer -> F.pred
                val i_convert :
                  Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                val round : Ctypes.c_float -> real -> real
                val f_guard : Ctypes.c_float -> real -> F.pred
                val f_convert :
                  Ctypes.c_float -> Ctypes.c_float -> real -> real
                val has_type : abstract -> Cil_types.logic_type -> F.pred
                val get_range_index : array -> interval -> abstract
                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 equal_pointer_bool : pointer -> pointer -> boolean
                val lt_pointer_bool : pointer -> pointer -> boolean
                val le_pointer_bool : pointer -> pointer -> boolean
                val lt_pointer : pointer -> pointer -> F.pred
                val le_pointer : pointer -> pointer -> F.pred
                val minus_pointer : pointer -> pointer -> integer
                val is_null : pointer -> boolean
                val null : pointer
                val tau_of_object : Ctypes.c_object -> Formula.tau
                val tau_of_ctype : Cil_types.typ -> Formula.tau
                val int_format : format
                val real_format : format
                val pointer_format : format
                val record_format : format
                val urecord_format : format
                val array_format : format -> format
                val format_of_object : Ctypes.c_object -> format
                val decode : format -> abstract -> 'F.term
                val encode : format -> 'F.term -> abstract
                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
                val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
                val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
                val eq_record :
                  Cil_types.compinfo -> record -> record -> F.pred
              end
            val i_neg : Ctypes.c_int -> D.integer -> D.integer
            val i_op :
              Ctypes.c_int ->
              Formula.integer_op -> D.integer -> D.integer -> D.integer
            val i_cmp :
              Ctypes.c_int ->
              Formula.cmp_op -> D.integer -> D.integer -> D.boolean
            val bits_not : Ctypes.c_int -> D.integer -> D.integer
            val bits_and :
              Ctypes.c_int -> D.integer -> D.integer -> D.integer
            val bits_or : Ctypes.c_int -> D.integer -> D.integer -> D.integer
            val bits_xor :
              Ctypes.c_int -> D.integer -> D.integer -> D.integer
            val bits_lshift :
              Ctypes.c_int -> D.integer -> D.integer -> D.integer
            val bits_rshift :
              Ctypes.c_int -> D.integer -> D.integer -> D.integer
          end
        module R :
          sig
            module D :
              sig
                module F :
                  sig
                    type 'a term = 'Model.D.F.term
                    type pred = Model.D.F.pred
                    val e_int : int -> Formula.integer term
                    val e_call :
                      string ->
                      Formula.abstract term list -> Formula.abstract term
                    val p_call : string -> Formula.abstract term list -> pred
                    val wrap : 'a term -> Formula.abstract term
                    val unwrap : Formula.abstract term -> 'a term
                    val e_true : Formula.boolean term
                    val e_false : Formula.boolean term
                    val e_int : int -> Formula.integer term
                    val e_float : float -> Formula.real term
                    val e_icst : string -> Formula.integer term
                    val e_rcst : string -> Formula.real term
                    val e_int64 : int64 -> Formula.integer term
                    val e_ineg : Formula.integer term -> Formula.integer term
                    val e_rneg : Formula.real term -> Formula.real term
                    val e_iop :
                      Formula.integer_op ->
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_rop :
                      Formula.real_op ->
                      Formula.real term ->
                      Formula.real term -> Formula.real term
                    val e_icmp :
                      Formula.cmp_op ->
                      Formula.integer term ->
                      Formula.integer term -> Formula.boolean term
                    val e_rcmp :
                      Formula.cmp_op ->
                      Formula.real term ->
                      Formula.real term -> Formula.boolean term
                    val p_icmp :
                      Formula.cmp_op ->
                      Formula.integer term -> Formula.integer term -> pred
                    val p_rcmp :
                      Formula.cmp_op ->
                      Formula.real term -> Formula.real term -> pred
                    val e_bnot : Formula.integer term -> Formula.integer term
                    val e_band :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_bor :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_bxor :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_lshift :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val e_rshift :
                      Formula.integer term ->
                      Formula.integer term -> Formula.integer term
                    val integer_of_real :
                      Formula.real term -> Formula.integer term
                    val real_of_integer :
                      Formula.integer term -> Formula.real term
                    val e_bool : Formula.boolean term -> Formula.integer term
                    val e_not : Formula.boolean term -> Formula.boolean term
                    val e_and :
                      Formula.boolean term ->
                      Formula.boolean term -> Formula.boolean term
                    val e_or :
                      Formula.boolean term ->
                      Formula.boolean term -> Formula.boolean term
                    val e_cond :
                      Formula.boolean term -> 'a term -> 'a term -> 'a term
                    val p_cond : Formula.boolean term -> pred -> pred -> pred
                    val p_true : pred
                    val p_false : pred
                    val p_bool : Formula.boolean term -> 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 var = Model.D.F.var
                    type pool = Model.D.F.pool
                    val pool : unit -> pool
                    val fresh : pool -> string -> Formula.kind -> var
                    val freshen : pool -> var -> var
                    val var : var -> 'a term
                    val eq_var : var -> var -> bool
                    val name_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_closed : 'a term -> bool
                    val pred_closed : pred -> bool
                    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.D.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_term : Format.formatter -> 'a term -> unit
                    val pp_pred : Format.formatter -> pred -> unit
                    val pp_decl :
                      Format.formatter -> pred Formula.declaration -> unit
                    val pp_goal : Format.formatter -> string -> pred -> unit
                  end
                type format = Formula.m_format F.term
                type abstract = Formula.abstract F.term
                type integer = Formula.integer F.term
                type real = Formula.real F.term
                type boolean = Formula.boolean F.term
                type record = Formula.m_array F.term
                type urecord = Formula.m_array F.term
                type array = Formula.m_array F.term
                type set = Formula.m_set F.term
                type name = Formula.integer F.term
                type pointer = Formula.m_pointer F.term
                val pp_kind : Format.formatter -> Mdata.kind -> unit
                type interval =
                  Model.D.interval = {
                  inf : integer option;
                  sup : integer option;
                }
                type 'a assigned =
                  'Model.D.assigned =
                    Aloc of Ctypes.c_object * 'a
                  | Arange of Ctypes.c_object * 'a * interval
                val pp_interval : Format.formatter -> interval -> unit
                val e_app0 : string -> 'F.term
                val e_app1 : string -> 'F.term -> 'F.term
                val e_app2 : string -> 'F.term -> 'F.term -> 'F.term
                val e_app3 :
                  string -> 'F.term -> 'F.term -> 'F.term -> 'F.term
                val e_app4 :
                  string ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term
                val e_app5 :
                  string ->
                  'F.term ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term
                val p_app0 : string -> F.pred
                val p_app1 : string -> 'F.term -> F.pred
                val p_app2 : string -> 'F.term -> 'F.term -> F.pred
                val p_app3 :
                  string -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val p_app4 :
                  string ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val p_app5 :
                  string ->
                  'F.term ->
                  'F.term -> 'F.term -> 'F.term -> 'F.term -> F.pred
                val tau_of_logic_type : Cil_types.logic_type -> Formula.tau
                type context = Model.D.context
                type bindings = Model.D.bindings
                class type hint =
                  object
                    method capture : F.var list -> unit
                    method has_var : F.var list -> bool
                    method pretty : Format.formatter -> unit
                    method subst : F.var -> Formula.abstract F.term -> unit
                  end
                val closed : bindings
                val close : bindings -> F.pred -> F.pred
                val capture : hint list -> bindings -> unit
                val push :
                  string -> F.pool -> bindings -> hint list -> 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 -> Mdata.vkind -> F.var
                val alpha : F.var -> F.var option
                val pool : unit -> F.pool
                val vkind_of_var : F.var -> Mdata.vkind
                val has_vars : F.var list -> F.pred -> bool
                type substitution = Model.D.substitution
                val apply : substitution -> 'F.term -> 'F.term
                type havoc =
                  Model.D.havoc =
                    Fresh of F.var
                  | Update of F.var *
                      (substitution -> Formula.abstract F.term)
                val havoc_static : havoc list -> F.pred -> F.pred
                val havoc_inductive : havoc list -> F.pred -> F.pred
                val clear : unit -> unit
                val on_clear : (unit -> unit) -> unit
                val fresh_name : string -> string -> string
                val add_declaration : F.pred Formula.declaration -> unit
                val iter :
                  Formula.section ->
                  (F.pred Formula.declaration -> unit) -> unit
                val iter_all : (F.pred Formula.declaration -> unit) -> unit
                val dummy : unit -> F.pred
                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 -> Log.source 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 -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> 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 -> Log.source 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 -> F.pred Formula.item
                  end
                module Register :
                  functor (D : Declarator->
                    sig
                      type t = D.t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                    end
                module Varinfo :
                  sig
                    type t = Cil_types.varinfo
                    module H :
                      sig
                        type key = Model.D.Varinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Varaddr.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Fieldinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Compinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Arrayinfo.H.key
                        type 'a t = 'Model.D.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 -> Log.source 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.D.Logicvar.H.key
                        type 'a t = 'Model.D.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 -> Log.source option
                    val pp_title : Format.formatter -> t -> unit
                    val pp_descr : Format.formatter -> t -> unit
                  end
                module type Indexed =
                  sig
                    type t
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Dindex :
                  functor (I : Identifiable->
                    sig
                      type t = I.t
                      val define : t -> unit
                      val get_definition : t -> F.pred Formula.declaration
                      val on_definition :
                        (t -> F.pred Formula.declaration -> unit) -> unit
                      val get_ind : t -> integer
                    end
                module Findex :
                  sig
                    type t = Cil_types.fieldinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Xindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Aindex :
                  sig
                    type t = Cil_types.varinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                module Tindex :
                  sig
                    type t = Cil_types.compinfo
                    val define : t -> unit
                    val get_definition : t -> F.pred Formula.declaration
                    val on_definition :
                      (t -> F.pred Formula.declaration -> unit) -> unit
                    val get_ind : t -> integer
                  end
                val modulo : Ctypes.c_int -> integer -> integer
                val guard : Ctypes.c_int -> integer -> F.pred
                val i_convert :
                  Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                val round : Ctypes.c_float -> real -> real
                val f_guard : Ctypes.c_float -> real -> F.pred
                val f_convert :
                  Ctypes.c_float -> Ctypes.c_float -> real -> real
                val has_type : abstract -> Cil_types.logic_type -> F.pred
                val get_range_index : array -> interval -> abstract
                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 equal_pointer_bool : pointer -> pointer -> boolean
                val lt_pointer_bool : pointer -> pointer -> boolean
                val le_pointer_bool : pointer -> pointer -> boolean
                val lt_pointer : pointer -> pointer -> F.pred
                val le_pointer : pointer -> pointer -> F.pred
                val minus_pointer : pointer -> pointer -> integer
                val is_null : pointer -> boolean
                val null : pointer
                val tau_of_object : Ctypes.c_object -> Formula.tau
                val tau_of_ctype : Cil_types.typ -> Formula.tau
                val int_format : format
                val real_format : format
                val pointer_format : format
                val record_format : format
                val urecord_format : format
                val array_format : format -> format
                val format_of_object : Ctypes.c_object -> format
                val decode : format -> abstract -> 'F.term
                val encode : format -> 'F.term -> abstract
                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
                val equal : Ctypes.c_object -> abstract -> abstract -> F.pred
                val eq_array : Ctypes.arrayinfo -> array -> array -> F.pred
                val eq_record :
                  Cil_types.compinfo -> record -> record -> F.pred
              end
            val f_neg : Ctypes.c_float -> D.real -> D.real
            val f_op :
              Ctypes.c_float -> Formula.real_op -> D.real -> D.real -> D.real
            val f_cmp :
              Ctypes.c_float ->
              Formula.cmp_op -> D.real -> D.real -> D.boolean
          end
        type loc = Model.loc
        val loc_of_pointer : Ctypes.c_object -> D.pointer -> loc
        val pointer_of_loc : loc -> D.pointer
        val cast_loc_to_int :
          Cil_types.typ -> loc -> Ctypes.c_int -> D.integer
        val cast_int_to_loc :
          Ctypes.c_int -> D.integer -> Cil_types.typ -> loc
        val pp_loc : Format.formatter -> loc -> unit
        type value =
          Datalib.Cvalues(Model).value =
            V_int of Ctypes.c_int * D.integer
          | V_float of Ctypes.c_float * D.real
          | V_pointer of Cil_types.typ * loc
          | V_record of Cil_types.compinfo * D.record
          | V_union of Cil_types.compinfo * D.urecord
          | V_array of Ctypes.arrayinfo * D.array
        val pp_value : Format.formatter -> value -> unit
        val logic_of_value : value -> D.abstract
        val value_of_logic : Ctypes.c_object -> D.abstract -> value
        val cvar :
          '->
          Hoare_mem.Create.Shared.Globals.t -> Hoare_mem.Create.Model.loc
        val field :
          Hoare_mem.Create.Model.loc ->
          Cil_types.fieldinfo -> Hoare_mem.Create.Model.loc
        val index :
          Hoare_mem.Create.Model.loc ->
          '->
          Hoare_mem.Create.Model.D.integer -> Hoare_mem.Create.Model.loc
        val shift :
          Hoare_mem.Create.Model.loc ->
          '->
          Formula.integer Hoare_mem.Create.F.term ->
          Hoare_mem.Create.Model.loc
        val startof :
          Hoare_mem.Create.Model.loc -> '-> Hoare_mem.Create.Model.loc
        val field_access :
          Formula.abstract Hoare_mem.Create.F.term ->
          Cil_types.fieldinfo -> Hoare_mem.Create.Model.D.abstract
        type mem = {
          variables : Hoare_mem.Create.F.var Cil_datatype.Varinfo.Hashtbl.t;
        }
        type frame = {
          kf : Kernel_function.t;
          mutable states : (Clabels.c_label * Hoare_mem.Create.mem) list;
          mutable result : Hoare_mem.Create.F.var option;
          mutable exit_status : Hoare_mem.Create.F.var option;
          mutable ret_type : Cil_types.typ option;
        }
        val new_frame :
          Kernel_function.t ->
          m_here:Hoare_mem.Create.mem option ->
          m_pre:Hoare_mem.Create.mem option ->
          m_post:Hoare_mem.Create.mem option ->
          Hoare_mem.Create.F.var option -> Hoare_mem.Create.frame
        val new_mem : unit -> Hoare_mem.Create.mem
        val mem_at :
          Hoare_mem.Create.frame -> Clabels.c_label -> Hoare_mem.Create.mem
        val get_var :
          create:bool ->
          Hoare_mem.Create.mem ->
          Cil_datatype.Varinfo.Hashtbl.key -> Hoare_mem.Create.F.var
        val result :
          Hoare_mem.Create.frame -> Hoare_mem.Create.F.var * Cil_types.typ
        val exit_status : Hoare_mem.Create.frame -> Hoare_mem.Create.F.var
        val set_exit_status :
          Hoare_mem.Create.frame ->
          Hoare_mem.Create.F.var -> Hoare_mem.Create.frame
        val get_exit_status :
          Hoare_mem.Create.frame -> Hoare_mem.Create.F.var option
        val term_load :
          Hoare_mem.Create.mem ->
          Hoare_mem.Create.Model.loc ->
          Formula.abstract Hoare_mem.Create.F.term
        val load :
          Hoare_mem.Create.mem ->
          Ctypes.c_object -> Hoare_mem.Create.Model.loc -> value
        val base_address :
          '-> Hoare_mem.Create.Model.loc -> Hoare_mem.Create.Model.loc
        val block_length :
          '-> Hoare_mem.Create.Model.loc -> Formula.integer D.F.term
        type wp = Hoare_mem.Create.F.pred
        val update_at_label :
          Hoare_mem.Create.frame ->
          Clabels.c_label ->
          Hoare_mem.Create.Model.D.F.pred -> Hoare_mem.Create.Model.D.F.pred
        val quantify_at_label :
          Hoare_mem.Create.frame ->
          Clabels.c_label ->
          Hoare_mem.Create.Model.D.F.pred -> Hoare_mem.Create.Model.D.F.pred
        val mk_mu :
          Hoare_mem.Create.mem ->
          Hoare_mem.Create.Model.loc ->
          Hoare_mem.Create.F.var *
          (Hoare_mem.Create.Model.D.abstract ->
           Formula.abstract Hoare_mem.Create.F.term) *
          (Hoare_mem.Create.Model.D.abstract ->
           Formula.abstract Hoare_mem.Create.F.term ->
           Hoare_mem.Create.Model.D.abstract)
        val get_var_and_mu :
          Hoare_mem.Create.mem ->
          Hoare_mem.Create.Model.loc ->
          Formula.abstract Hoare_mem.Create.F.term ->
          Hoare_mem.Create.F.var * Hoare_mem.Create.Model.D.abstract
        val subst :
          Hoare_mem.Create.frame ->
          Hoare_mem.Create.Model.loc ->
          Formula.abstract Hoare_mem.Create.F.term ->
          Hoare_mem.Create.Model.D.F.pred -> Hoare_mem.Create.Model.D.F.pred
        val subst_lval :
          Hoare_mem.Create.frame ->
          '->
          Hoare_mem.Create.Model.loc ->
          value ->
          Hoare_mem.Create.Model.D.F.pred -> Hoare_mem.Create.Model.D.F.pred
        val subst_result :
          Hoare_mem.Create.frame ->
          value option ->
          Hoare_mem.Create.Model.D.F.pred -> Hoare_mem.Create.Model.D.F.pred
        val add_array_length_hyp :
          '->
          Cil_types.varinfo ->
          Hoare_mem.Create.F.pred -> Hoare_mem.Create.F.pred
        val add_var_decl_hyp :
          '->
          Hoare_mem.Create.F.pred ->
          Cil_types.varinfo -> Hoare_mem.Create.F.pred
        val local_scope :
          Hoare_mem.Create.frame ->
          Cil_types.varinfo list ->
          Mcfg.scope -> Hoare_mem.Create.F.pred -> Hoare_mem.Create.F.pred
        val valid :
          '->
          Hoare_mem.Create.Model.loc Hoare_mem.Create.Model.D.assigned ->
          D.F.pred
        val separated :
          Hoare_mem.Create.Model.loc Hoare_mem.Create.Model.D.assigned ->
          Hoare_mem.Create.Model.loc Hoare_mem.Create.Model.D.assigned ->
          D.F.pred
        type m_dzone
        type dzone = Hoare_mem.Create.m_dzone Hoare_mem.Create.F.term
        val tau_of_dzone : Formula.tau
        val dzone_assigned : '-> 'b
        val dzone_subset : '-> '-> 'c
        val dzone_union : '-> '-> 'c
        val dzone_empty : unit -> 'a
        val effect_supported : bool
        type region
        val pp_region : '-> '-> unit
        val region_assigned : '-> 'b
        val region_empty : '-> 'b
        val region_union : '-> '-> 'c
        val region_included : '-> '-> 'c
        val region_separated : '-> '-> 'c
        val region_fingerprint : '-> '-> 'c
        val region_supported : bool
        val assigns_goal : '-> '-> '-> 'd
        val assigns_supported : bool
        val subst_havoc :
          Hoare_mem.Create.frame ->
          Hoare_mem.Create.Model.loc Hoare_mem.Create.Model.D.assigned ->
          Hoare_mem.Create.Model.D.havoc list
        type closure = Cil_types.varinfo * string
        val pp_closure :
          Format.formatter -> Cil_types.varinfo * string -> unit
        val userdef_frame : unit -> Hoare_mem.Create.frame
        val collect_signature :
          '->
          '-> '-> 'c list * ('b * 'a) list -> 'c list * ('b * 'a) list
        val userdef_signature :
          Hoare_mem.Create.frame ->
          '->
          '->
          Hoare_mem.Create.F.var list *
          (Cil_datatype.Varinfo.Hashtbl.key * string) list
        val userdef_closure :
          Hoare_mem.Create.mem ->
          Cil_datatype.Varinfo.Hashtbl.key * '-> 'Hoare_mem.Create.F.term
        val label_at_closure : 'a * '-> 'b
      end