functor (M : Mlogic.S->
  sig
    module F :
      sig
        type var = M.F.var
        type 'a term = 'M.F.term
        type pred = M.F.pred
        type abstract = Formula.m_abstract term
        type integer = Formula.m_integer term
        type real = Formula.m_real term
        type boolean = Formula.m_boolean term
        type record = Formula.m_record term
        type urecord = Formula.m_array term
        type array = Formula.m_array term
        type set = Formula.m_set term
        type name = Formula.m_integer term
        type decl = (var, abstract, pred) Formula.declaration
        val e_int : int -> integer
        val e_call : string -> abstract list -> abstract
        val p_call : string -> abstract list -> pred
        val wrap : 'a term -> abstract
        val unwrap : abstract -> 'a term
        val clear : unit -> unit
        val on_clear : (unit -> unit) -> unit
        val fresh_name : string -> string -> string
        val add_declaration : decl -> unit
        val has_declaration : string -> bool
        val iter_all : (string -> unit) -> (decl -> unit) -> unit
        module type Identifiable =
          sig
            type t
            module H : Hashtbl.S
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module type Registry =
          sig
            type t
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
          end
        module type Declarator =
          sig
            type t
            module H : Hashtbl.S
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
            val clear : unit -> unit
            val section : Formula.section
            val declare : t -> string -> (var, abstract, pred) Formula.item
          end
        module DRegister :
          functor (D : Declarator->
            sig
              type t = D.t
              val define : t -> unit
              val get_definition : t -> decl
              val on_definition : (t -> decl -> unit) -> unit
            end
        module Varinfo :
          sig
            type t = Cil_types.varinfo
            module H :
              sig
                type key = M.F.Varinfo.H.key
                type 'a t = 'M.F.Varinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Varaddr :
          sig
            type t = Cil_types.varinfo
            module H :
              sig
                type key = M.F.Varaddr.H.key
                type 'a t = 'M.F.Varaddr.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Fieldinfo :
          sig
            type t = Cil_types.fieldinfo
            module H :
              sig
                type key = M.F.Fieldinfo.H.key
                type 'a t = 'M.F.Fieldinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Compinfo :
          sig
            type t = Cil_types.compinfo
            module H :
              sig
                type key = M.F.Compinfo.H.key
                type 'a t = 'M.F.Compinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Arrayinfo :
          sig
            type t = Ctypes.arrayinfo
            module H :
              sig
                type key = M.F.Arrayinfo.H.key
                type 'a t = 'M.F.Arrayinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Logicvar :
          sig
            type t = Cil_types.logic_var
            module H :
              sig
                type key = M.F.Logicvar.H.key
                type 'a t = 'M.F.Logicvar.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module LTypeinfo :
          sig
            type t = Cil_types.logic_type
            module H :
              sig
                type key = M.F.LTypeinfo.H.key
                type 'a t = 'M.F.LTypeinfo.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module Cobject :
          sig
            type t = Ctypes.c_object
            module H :
              sig
                type key = M.F.Cobject.H.key
                type 'a t = 'M.F.Cobject.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        module ArrayDim :
          sig
            type t = Ctypes.c_object * int
            module H :
              sig
                type key = M.F.ArrayDim.H.key
                type 'a t = 'M.F.ArrayDim.H.t
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
                val find : 'a t -> key -> 'a
                val find_all : 'a t -> key -> 'a list
                val replace : 'a t -> key -> '-> unit
                val mem : 'a t -> key -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val length : 'a t -> int
              end
            val index : t -> H.key
            val prefix : string
            val basename : t -> string
            val location : t -> Lexing.position option
            val pp_title : Format.formatter -> t -> unit
            val pp_descr : Format.formatter -> t -> unit
          end
        val adt_decl : Cil_types.logic_type_info -> string
        val pp_tau : Format.formatter -> Formula.tau -> unit
        val e_true : boolean
        val e_false : boolean
        val e_float : float -> real
        val e_icst : string -> integer
        val e_rcst : string -> real
        val e_int64 : int64 -> integer
        val e_ineg : integer -> integer
        val e_rneg : real -> real
        val e_iop : Formula.int_op -> integer -> integer -> integer
        val e_rop : Formula.real_op -> real -> real -> real
        val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
        val e_rcmp : Formula.cmp_op -> real -> real -> boolean
        val p_icmp : Formula.cmp_op -> integer -> integer -> pred
        val p_rcmp : Formula.cmp_op -> real -> real -> pred
        val e_bnot : integer -> integer
        val e_band : integer -> integer -> integer
        val e_bor : integer -> integer -> integer
        val e_bxor : integer -> integer -> integer
        val e_lshift : integer -> integer -> integer
        val e_rshift : integer -> integer -> integer
        val integer_of_real : real -> integer
        val real_of_integer : integer -> real
        val e_bool : boolean -> integer
        val e_not : boolean -> boolean
        val e_and : boolean -> boolean -> boolean
        val e_or : boolean -> boolean -> boolean
        val e_cond : boolean -> 'a term -> 'a term -> 'a term
        val p_cond : boolean -> pred -> pred -> pred
        val e_getfield : Cil_types.fieldinfo -> record -> abstract
        val e_setfield : Cil_types.fieldinfo -> record -> abstract -> record
        val e_access : array -> integer -> abstract
        val e_update : array -> integer -> abstract -> array
        val p_true : pred
        val p_false : pred
        val p_bool : boolean -> pred
        val p_and : pred -> pred -> pred
        val p_or : pred -> pred -> pred
        val p_xor : pred -> pred -> pred
        val p_not : pred -> pred
        val p_implies : pred -> pred -> pred
        val p_iff : pred -> pred -> pred
        val p_eq : 'a term -> 'a term -> pred
        val p_neq : 'a term -> 'a term -> pred
        val p_conj : pred list -> pred
        val p_disj : pred list -> pred
        val p_named : string -> pred -> pred
        val is_true : pred -> bool
        val is_false : pred -> bool
        val huge_term : int -> 'a term -> bool
        val huge_pred : int -> pred -> bool
        type pool = M.F.pool
        val pool : unit -> pool
        val p_fresh : pool -> string -> Formula.kind -> var
        val p_freshen : pool -> var -> var
        val var : var -> 'a term
        val eq_var : var -> var -> bool
        val name_of_var : var -> string
        val basename_of_var : var -> string
        val tau_of_var : var -> Formula.tau
        val kind_of_var : var -> Formula.kind
        val term_has_var : var list -> 'a term -> bool
        val pred_has_var : var list -> pred -> bool
        val term_calls : string -> 'a term -> bool
        val pred_calls : string -> pred -> bool
        val term_closed : 'a term -> bool
        val pred_closed : pred -> bool
        val freevars : pred -> var list
        val p_forall : var list -> pred -> pred
        val p_exists : var list -> pred -> pred
        val p_subst : (var -> var option) -> var -> 'a term -> pred -> pred
        val e_subst :
          (var -> var option) -> var -> 'a term -> 'b term -> 'b term
        val e_rename : (var * var) list -> 'a term -> 'a term
        val equal_terms : 'a term -> 'a term -> bool
        type alpha = M.F.alpha
        val empty_alpha : alpha
        val fold_alpha : (var -> var -> '-> 'a) -> alpha -> '-> 'a
        val p_more_alpha_cv : alpha -> pred -> alpha * pred
        val p_alpha_cv : pred -> var list * pred
        val pp_var : Format.formatter -> var -> unit
        val pp_section : Format.formatter -> string -> unit
        val pp_term : Format.formatter -> 'a term -> unit
        val pp_pred : Format.formatter -> pred -> unit
        val pp_decl : Format.formatter -> decl -> unit
        val pp_goal : Format.formatter -> string -> pred -> unit
        val pp_vkind : Format.formatter -> Formula.kind -> unit
        val e_app0 : string -> 'a term
        val e_app1 : string -> 'a term -> 'b term
        val e_app2 : string -> 'a term -> 'b term -> 'c term
        val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
        val e_app4 :
          string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
        val e_app5 :
          string ->
          'a term -> 'b term -> 'c term -> 'd term -> 'e term -> 'f term
        val p_app0 : string -> pred
        val p_app1 : string -> 'a term -> pred
        val p_app2 : string -> 'a term -> 'b term -> pred
        val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
        val p_app4 :
          string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
        val p_app5 :
          string ->
          'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
        val dummy : unit -> pred
        val i_zero : integer
        val r_zero : real
        val i_one : integer
        val i_add : integer -> integer -> integer
        val i_mult : integer -> integer -> integer
        val i_sub : integer -> integer -> integer
        val guard : Ctypes.c_int -> integer -> pred
        val modulo : Ctypes.c_int -> integer -> integer
        val i_convert : Ctypes.c_int -> Ctypes.c_int -> integer -> integer
        type interval =
          M.F.interval = {
          inf : integer option;
          sup : integer option;
        }
        type 'a assigned =
          'M.F.assigned =
            Aloc of Ctypes.c_object * 'a
          | Arange of Ctypes.c_object * 'a * interval
        type havoc =
          M.F.havoc =
            Fresh of var
          | Update of var * ((var * var) list -> abstract)
        val pp_interval : Format.formatter -> interval -> unit
        val set_range_index : array -> interval -> array
        val empty : set
        val singleton : abstract -> set
        val union : set -> set -> set
        val unions : set list -> set
        val inter : set -> set -> set
        val remove : set -> set -> set
        val set_of_list : abstract list -> set
        val add_set : set -> set -> set
        val mult_set : set -> set -> set
        val neg_set : set -> set
        val interval : interval -> set
        val acc_field : record -> Cil_types.fieldinfo -> abstract
        val upd_field : record -> Cil_types.fieldinfo -> abstract -> record
        val acc_index : array -> integer -> abstract
        val upd_index : array -> integer -> abstract -> array
        module type Indexed =
          sig
            type t
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Dindex :
          functor (I : Identifiable->
            sig
              type t = I.t
              val define : t -> unit
              val get_definition : t -> decl
              val on_definition : (t -> decl -> unit) -> unit
              val get_ind : t -> integer
              val has_ind : t -> pred -> bool
            end
        module Findex :
          sig
            type t = Cil_types.fieldinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Xindex :
          sig
            type t = Cil_types.varinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Aindex :
          sig
            type t = Cil_types.varinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module Tindex :
          sig
            type t = Cil_types.compinfo
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
        module LTindex :
          sig
            type t = Cil_types.logic_type
            val define : t -> unit
            val get_definition : t -> decl
            val on_definition : (t -> decl -> unit) -> unit
            val get_ind : t -> integer
            val has_ind : t -> pred -> bool
          end
      end
    module L :
      sig
        module F :
          sig
            type var = M.F.var
            type 'a term = 'M.F.term
            type pred = M.F.pred
            type abstract = Formula.m_abstract term
            type integer = Formula.m_integer term
            type real = Formula.m_real term
            type boolean = Formula.m_boolean term
            type record = Formula.m_record term
            type urecord = Formula.m_array term
            type array = Formula.m_array term
            type set = Formula.m_set term
            type name = Formula.m_integer term
            type decl = (var, abstract, pred) Formula.declaration
            val e_int : int -> integer
            val e_call : string -> abstract list -> abstract
            val p_call : string -> abstract list -> pred
            val wrap : 'a term -> abstract
            val unwrap : abstract -> 'a term
            val clear : unit -> unit
            val on_clear : (unit -> unit) -> unit
            val fresh_name : string -> string -> string
            val add_declaration : decl -> unit
            val has_declaration : string -> bool
            val iter_all : (string -> unit) -> (decl -> unit) -> unit
            module type Identifiable =
              sig
                type t
                module H : Hashtbl.S
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module type Registry =
              sig
                type t
                val define : t -> unit
                val get_definition : t -> decl
                val on_definition : (t -> decl -> unit) -> unit
              end
            module type Declarator =
              sig
                type t
                module H : Hashtbl.S
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
                val clear : unit -> unit
                val section : Formula.section
                val declare :
                  t -> string -> (var, abstract, pred) Formula.item
              end
            module DRegister :
              functor (D : Declarator->
                sig
                  type t = D.t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                end
            module Varinfo :
              sig
                type t = Cil_types.varinfo
                module H :
                  sig
                    type key = M.F.Varinfo.H.key
                    type 'a t = 'M.F.Varinfo.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module Varaddr :
              sig
                type t = Cil_types.varinfo
                module H :
                  sig
                    type key = M.F.Varaddr.H.key
                    type 'a t = 'M.F.Varaddr.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module Fieldinfo :
              sig
                type t = Cil_types.fieldinfo
                module H :
                  sig
                    type key = M.F.Fieldinfo.H.key
                    type 'a t = 'M.F.Fieldinfo.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module Compinfo :
              sig
                type t = Cil_types.compinfo
                module H :
                  sig
                    type key = M.F.Compinfo.H.key
                    type 'a t = 'M.F.Compinfo.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module Arrayinfo :
              sig
                type t = Ctypes.arrayinfo
                module H :
                  sig
                    type key = M.F.Arrayinfo.H.key
                    type 'a t = 'M.F.Arrayinfo.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module Logicvar :
              sig
                type t = Cil_types.logic_var
                module H :
                  sig
                    type key = M.F.Logicvar.H.key
                    type 'a t = 'M.F.Logicvar.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module LTypeinfo :
              sig
                type t = Cil_types.logic_type
                module H :
                  sig
                    type key = M.F.LTypeinfo.H.key
                    type 'a t = 'M.F.LTypeinfo.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module Cobject :
              sig
                type t = Ctypes.c_object
                module H :
                  sig
                    type key = M.F.Cobject.H.key
                    type 'a t = 'M.F.Cobject.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            module ArrayDim :
              sig
                type t = Ctypes.c_object * int
                module H :
                  sig
                    type key = M.F.ArrayDim.H.key
                    type 'a t = 'M.F.ArrayDim.H.t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val copy : 'a t -> 'a t
                    val add : 'a t -> key -> '-> unit
                    val remove : 'a t -> key -> unit
                    val find : 'a t -> key -> 'a
                    val find_all : 'a t -> key -> 'a list
                    val replace : 'a t -> key -> '-> unit
                    val mem : 'a t -> key -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                  end
                val index : t -> H.key
                val prefix : string
                val basename : t -> string
                val location : t -> Lexing.position option
                val pp_title : Format.formatter -> t -> unit
                val pp_descr : Format.formatter -> t -> unit
              end
            val adt_decl : Cil_types.logic_type_info -> string
            val pp_tau : Format.formatter -> Formula.tau -> unit
            val e_true : boolean
            val e_false : boolean
            val e_float : float -> real
            val e_icst : string -> integer
            val e_rcst : string -> real
            val e_int64 : int64 -> integer
            val e_ineg : integer -> integer
            val e_rneg : real -> real
            val e_iop : Formula.int_op -> integer -> integer -> integer
            val e_rop : Formula.real_op -> real -> real -> real
            val e_icmp : Formula.cmp_op -> integer -> integer -> boolean
            val e_rcmp : Formula.cmp_op -> real -> real -> boolean
            val p_icmp : Formula.cmp_op -> integer -> integer -> pred
            val p_rcmp : Formula.cmp_op -> real -> real -> pred
            val e_bnot : integer -> integer
            val e_band : integer -> integer -> integer
            val e_bor : integer -> integer -> integer
            val e_bxor : integer -> integer -> integer
            val e_lshift : integer -> integer -> integer
            val e_rshift : integer -> integer -> integer
            val integer_of_real : real -> integer
            val real_of_integer : integer -> real
            val e_bool : boolean -> integer
            val e_not : boolean -> boolean
            val e_and : boolean -> boolean -> boolean
            val e_or : boolean -> boolean -> boolean
            val e_cond : boolean -> 'a term -> 'a term -> 'a term
            val p_cond : boolean -> pred -> pred -> pred
            val e_getfield : Cil_types.fieldinfo -> record -> abstract
            val e_setfield :
              Cil_types.fieldinfo -> record -> abstract -> record
            val e_access : array -> integer -> abstract
            val e_update : array -> integer -> abstract -> array
            val p_true : pred
            val p_false : pred
            val p_bool : boolean -> pred
            val p_and : pred -> pred -> pred
            val p_or : pred -> pred -> pred
            val p_xor : pred -> pred -> pred
            val p_not : pred -> pred
            val p_implies : pred -> pred -> pred
            val p_iff : pred -> pred -> pred
            val p_eq : 'a term -> 'a term -> pred
            val p_neq : 'a term -> 'a term -> pred
            val p_conj : pred list -> pred
            val p_disj : pred list -> pred
            val p_named : string -> pred -> pred
            val is_true : pred -> bool
            val is_false : pred -> bool
            val huge_term : int -> 'a term -> bool
            val huge_pred : int -> pred -> bool
            type pool = M.F.pool
            val pool : unit -> pool
            val p_fresh : pool -> string -> Formula.kind -> var
            val p_freshen : pool -> var -> var
            val var : var -> 'a term
            val eq_var : var -> var -> bool
            val name_of_var : var -> string
            val basename_of_var : var -> string
            val tau_of_var : var -> Formula.tau
            val kind_of_var : var -> Formula.kind
            val term_has_var : var list -> 'a term -> bool
            val pred_has_var : var list -> pred -> bool
            val term_calls : string -> 'a term -> bool
            val pred_calls : string -> pred -> bool
            val term_closed : 'a term -> bool
            val pred_closed : pred -> bool
            val freevars : pred -> var list
            val p_forall : var list -> pred -> pred
            val p_exists : var list -> pred -> pred
            val p_subst :
              (var -> var option) -> var -> 'a term -> pred -> pred
            val e_subst :
              (var -> var option) -> var -> 'a term -> 'b term -> 'b term
            val e_rename : (var * var) list -> 'a term -> 'a term
            val equal_terms : 'a term -> 'a term -> bool
            type alpha = M.F.alpha
            val empty_alpha : alpha
            val fold_alpha : (var -> var -> '-> 'a) -> alpha -> '-> 'a
            val p_more_alpha_cv : alpha -> pred -> alpha * pred
            val p_alpha_cv : pred -> var list * pred
            val pp_var : Format.formatter -> var -> unit
            val pp_section : Format.formatter -> string -> unit
            val pp_term : Format.formatter -> 'a term -> unit
            val pp_pred : Format.formatter -> pred -> unit
            val pp_decl : Format.formatter -> decl -> unit
            val pp_goal : Format.formatter -> string -> pred -> unit
            val pp_vkind : Format.formatter -> Formula.kind -> unit
            val e_app0 : string -> 'a term
            val e_app1 : string -> 'a term -> 'b term
            val e_app2 : string -> 'a term -> 'b term -> 'c term
            val e_app3 : string -> 'a term -> 'b term -> 'c term -> 'd term
            val e_app4 :
              string -> 'a term -> 'b term -> 'c term -> 'd term -> 'e term
            val e_app5 :
              string ->
              'a term -> 'b term -> 'c term -> 'd term -> 'e term -> 'f term
            val p_app0 : string -> pred
            val p_app1 : string -> 'a term -> pred
            val p_app2 : string -> 'a term -> 'b term -> pred
            val p_app3 : string -> 'a term -> 'b term -> 'c term -> pred
            val p_app4 :
              string -> 'a term -> 'b term -> 'c term -> 'd term -> pred
            val p_app5 :
              string ->
              'a term -> 'b term -> 'c term -> 'd term -> 'e term -> pred
            val dummy : unit -> pred
            val i_zero : integer
            val r_zero : real
            val i_one : integer
            val i_add : integer -> integer -> integer
            val i_mult : integer -> integer -> integer
            val i_sub : integer -> integer -> integer
            val guard : Ctypes.c_int -> integer -> pred
            val modulo : Ctypes.c_int -> integer -> integer
            val i_convert :
              Ctypes.c_int -> Ctypes.c_int -> integer -> integer
            type interval =
              M.F.interval = {
              inf : integer option;
              sup : integer option;
            }
            type 'a assigned =
              'M.F.assigned =
                Aloc of Ctypes.c_object * 'a
              | Arange of Ctypes.c_object * 'a * interval
            type havoc =
              M.F.havoc =
                Fresh of var
              | Update of var * ((var * var) list -> abstract)
            val pp_interval : Format.formatter -> interval -> unit
            val set_range_index : array -> interval -> array
            val empty : set
            val singleton : abstract -> set
            val union : set -> set -> set
            val unions : set list -> set
            val inter : set -> set -> set
            val remove : set -> set -> set
            val set_of_list : abstract list -> set
            val add_set : set -> set -> set
            val mult_set : set -> set -> set
            val neg_set : set -> set
            val interval : interval -> set
            val acc_field : record -> Cil_types.fieldinfo -> abstract
            val upd_field :
              record -> Cil_types.fieldinfo -> abstract -> record
            val acc_index : array -> integer -> abstract
            val upd_index : array -> integer -> abstract -> array
            module type Indexed =
              sig
                type t
                val define : t -> unit
                val get_definition : t -> decl
                val on_definition : (t -> decl -> unit) -> unit
                val get_ind : t -> integer
                val has_ind : t -> pred -> bool
              end
            module Dindex :
              functor (I : Identifiable->
                sig
                  type t = I.t
                  val define : t -> unit
                  val get_definition : t -> decl
                  val on_definition : (t -> decl -> unit) -> unit
                  val get_ind : t -> integer
                  val has_ind : t -> pred -> bool
                end
            module Findex :
              sig
                type t = Cil_types.fieldinfo
                val define : t -> unit
                val get_definition : t -> decl
                val on_definition : (t -> decl -> unit) -> unit
                val get_ind : t -> integer
                val has_ind : t -> pred -> bool
              end
            module Xindex :
              sig
                type t = Cil_types.varinfo
                val define : t -> unit
                val get_definition : t -> decl
                val on_definition : (t -> decl -> unit) -> unit
                val get_ind : t -> integer
                val has_ind : t -> pred -> bool
              end
            module Aindex :
              sig
                type t = Cil_types.varinfo
                val define : t -> unit
                val get_definition : t -> decl
                val on_definition : (t -> decl -> unit) -> unit
                val get_ind : t -> integer
                val has_ind : t -> pred -> bool
              end
            module Tindex :
              sig
                type t = Cil_types.compinfo
                val define : t -> unit
                val get_definition : t -> decl
                val on_definition : (t -> decl -> unit) -> unit
                val get_ind : t -> integer
                val has_ind : t -> pred -> bool
              end
            module LTindex :
              sig
                type t = Cil_types.logic_type
                val define : t -> unit
                val get_definition : t -> decl
                val on_definition : (t -> decl -> unit) -> unit
                val get_ind : t -> integer
                val has_ind : t -> pred -> bool
              end
          end
        type context = M.L.context
        type bindings = M.L.bindings
        val closed : bindings
        val close : bindings -> F.pred -> F.pred
        val push : string -> F.pool -> bindings -> context
        val pop : string -> context -> bindings
        val kill : string -> context -> unit
        val flush : string -> context -> F.pred -> F.pred
        val term_such_that :
          Formula.tau -> ('F.term -> F.pred) -> 'F.term
        val forall : F.var list -> F.pred -> F.pred
        val exists : F.var list -> F.pred -> F.pred
        val subst : F.var -> 'F.term -> F.pred -> F.pred
        val fresh : string -> Formula.kind -> F.var
        val alpha : F.var -> F.var option
        val pool : unit -> F.pool
        val vkind_of_var : F.var -> Formula.kind
        val has_context_vars : F.var list -> F.pred -> bool
        val has_type : F.abstract -> Cil_types.logic_type -> F.pred
        val is_comp : Cil_types.compinfo -> F.abstract -> F.pred
        val is_array : Ctypes.arrayinfo -> F.abstract -> F.pred
        val apply : (F.var * F.var) list -> 'F.term -> 'F.term
        val havoc_static : F.havoc list -> F.pred -> F.pred
        val havoc_inductive : F.havoc list -> F.pred -> F.pred
      end
    type user_formal =
        UF_logic of Cil_types.logic_var * Translate_prop.Create.F.var
      | UF_references of Cil_types.logic_var *
          Translate_prop.Create.F.var option *
          (Translate_prop.Create.F.var * M.formal * string) list
      | UF_closure of Translate_prop.Create.F.var * M.closure * string
    type userdef = {
      d_info : Cil_types.logic_info;
      d_callname : string;
      d_formals : Translate_prop.Create.user_formal list;
    }
    type axiomlabel = {
      a_name : string;
      a_defname : string;
      a_property : Translate_prop.Create.F.pred;
      a_memory : Translate_prop.Create.user_formal list;
    }
    module Hdef :
      sig
        type key = Cil_datatype.Logic_var.t
        type 'a t = 'Cil_datatype.Logic_var.Hashtbl.t
        val create : int -> 'a t
        val clear : 'a t -> unit
        val copy : 'a t -> 'a t
        val add : 'a t -> key -> '-> unit
        val remove : 'a t -> key -> unit
        val find : 'a t -> key -> 'a
        val find_all : 'a t -> key -> 'a list
        val replace : 'a t -> key -> '-> unit
        val mem : 'a t -> key -> bool
        val iter : (key -> '-> unit) -> 'a t -> unit
        val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
        val length : 'a t -> int
        val memo : 'a t -> key -> (key -> 'a) -> 'a
        module Key :
          sig
            type t = key
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
          end
        module Make :
          functor (Data : Datatype.S->
            sig
              type t = Data.t t
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
      end
    val user_axioms : (string, Translate_prop.Create.F.pred option) Hashtbl.t
    val user_axiomlabels :
      (string, Translate_prop.Create.axiomlabel option) Hashtbl.t
    val user_definitions :
      Translate_prop.Create.userdef Translate_prop.Create.Hdef.t
    val pp_closures :
      Format.formatter ->
      Translate_prop.Create.F.var list * (M.closure * string) list -> unit
    val pp_formals :
      Format.formatter -> Translate_prop.Create.F.var list -> unit
    module UserDefinition :
      sig
        val lock : unit Hdef.t
        val pp_userdef_title :
          Format.formatter -> Translate_prop.Create.userdef -> unit
        val pp_userformals :
          Format.formatter -> Translate_prop.Create.user_formal list -> unit
        val pp_userdef_descr :
          Format.formatter -> Translate_prop.Create.userdef -> unit
        val define :
          Translate_prop.Create.userdef ->
          (string *
           (Translate_prop.Create.F.var, Translate_prop.Create.F.abstract,
            Translate_prop.Create.F.pred)
           Formula.item)
          list -> unit
        val unlock : Translate_prop.Create.Hdef.key -> unit
        val lock : Translate_prop.Create.Hdef.key -> unit
      end
    module UserAxiom :
      sig
        type t = string
        val define : t -> unit
        val get_definition : t -> F.decl
        val on_definition : (t -> F.decl -> unit) -> unit
      end
    module UserAxiomDefs :
      sig
        val pp_labels : Format.formatter -> string list -> unit
        val pp_axiomdef_title :
          Format.formatter -> Translate_prop.Create.axiomlabel -> unit
        val pp_axiomdef_descr :
          Format.formatter -> Translate_prop.Create.axiomlabel -> unit
        val define : Translate_prop.Create.axiomlabel -> unit
        val is_defined : string -> bool
      end
    module Lmap :
      sig
        type key = Clabels.c_label
        type +'a t
        val empty : 'a t
        val is_empty : 'a t -> bool
        val mem : key -> 'a t -> bool
        val add : key -> '-> 'a t -> 'a t
        val singleton : key -> '-> 'a t
        val remove : key -> 'a t -> 'a t
        val merge :
          (key -> 'a option -> 'b option -> 'c option) ->
          'a t -> 'b t -> 'c t
        val compare : ('-> '-> int) -> 'a t -> 'a t -> int
        val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
        val iter : (key -> '-> unit) -> 'a t -> unit
        val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
        val for_all : (key -> '-> bool) -> 'a t -> bool
        val exists : (key -> '-> bool) -> 'a t -> bool
        val filter : (key -> '-> bool) -> 'a t -> 'a t
        val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
        val cardinal : 'a t -> int
        val bindings : 'a t -> (key * 'a) list
        val min_binding : 'a t -> key * 'a
        val max_binding : 'a t -> key * 'a
        val choose : 'a t -> key * 'a
        val split : key -> 'a t -> 'a t * 'a option * 'a t
        val find : key -> 'a t -> 'a
        val map : ('-> 'b) -> 'a t -> 'b t
        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      end
    type frame = {
      mutable states : M.mem Translate_prop.Create.Lmap.t;
      mutable result : Translate_prop.Create.F.var option;
      mutable status : Translate_prop.Create.F.var option;
      mutable return : Cil_types.typ option;
    }
    val new_frame :
      Kernel_function.t ->
      ?m_here:M.mem ->
      ?m_pre:M.mem ->
      ?m_post:M.mem ->
      ?x_result:Translate_prop.Create.F.var ->
      ?x_status:Translate_prop.Create.F.var ->
      unit -> Translate_prop.Create.frame
    val user_frame : unit -> Translate_prop.Create.frame
    val result : Translate_prop.Create.frame -> Translate_prop.Create.F.var
    val status : Translate_prop.Create.frame -> Translate_prop.Create.F.var
    type lvar_kind =
        Logic_cvar of Cil_types.varinfo
      | Logic_value of M.value
      | Logic_term of Translate_prop.Create.F.abstract
      | Logic_var of Translate_prop.Create.F.var
      | Logic_byref
    type env = {
      formals_in_pre : bool;
      frame : Translate_prop.Create.frame;
      label : Clabels.c_label;
      xvars : M.value Cil_datatype.Varinfo.Map.t;
      lvars : Translate_prop.Create.lvar_kind Cil_datatype.Logic_var.Map.t;
      mutable laddr :
        Translate_prop.Create.F.var Cil_datatype.Logic_var.Map.t;
    }
    val fresh_addr : Cil_types.logic_var -> Translate_prop.Create.F.var
    val addr_of_ref :
      Translate_prop.Create.env ->
      Cil_datatype.Logic_var.Map.key -> Translate_prop.Create.F.var
    val rec_apply_function :
      (Translate_prop.Create.env ->
       Cil_types.logic_info ->
       (Cil_types.logic_label * Cil_types.logic_label) list ->
       Cil_types.term list -> Translate_prop.Create.F.abstract)
      Pervasives.ref
    val lvar :
      Translate_prop.Create.env ->
      Cil_datatype.Logic_var.Map.key -> Translate_prop.Create.lvar_kind
    val xvar :
      Translate_prop.Create.env ->
      Cil_datatype.Varinfo.Map.key -> M.value option
    val fresh_local : Cil_types.logic_var -> Translate_prop.Create.F.var
    val fresh_logic_var :
      Translate_prop.Create.F.pool ->
      Cil_types.logic_var -> Translate_prop.Create.F.var
    val add_logic_vars :
      Translate_prop.Create.env ->
      Translate_prop.Create.F.pool ->
      Cil_datatype.Logic_var.Map.key list -> Translate_prop.Create.env
    val collect_logic_vars :
      Translate_prop.Create.env -> Translate_prop.Create.F.var list
    val bind_lvars :
      Translate_prop.Create.env ->
      (Cil_datatype.Logic_var.Map.key * Translate_prop.Create.F.abstract)
      list -> Translate_prop.Create.env
    val bind_lvar :
      Translate_prop.Create.env ->
      Cil_datatype.Logic_var.Map.key ->
      Translate_prop.Create.F.abstract -> Translate_prop.Create.env
    val bind_fresh :
      Translate_prop.Create.env ->
      Cil_datatype.Logic_var.Map.key ->
      Translate_prop.Create.F.var * Translate_prop.Create.env
    val env_at :
      Translate_prop.Create.env ->
      Clabels.c_label -> Translate_prop.Create.env
    val find_mem :
      Translate_prop.Create.env ->
      Translate_prop.Create.Lmap.key -> M.mem option
    val mem_at :
      Translate_prop.Create.env -> Translate_prop.Create.Lmap.key -> M.mem
    val mem_at_env : Translate_prop.Create.env -> M.mem
    val subst_result :
      Translate_prop.Create.env ->
      M.value option ->
      Translate_prop.Create.L.F.pred -> Translate_prop.Create.L.F.pred
    val result_type : Translate_prop.Create.env -> Cil_types.typ
    val exit_status :
      Translate_prop.Create.env -> Translate_prop.Create.F.var
    val env :
      Kernel_function.t ->
      ?m_here:M.mem ->
      ?m_pre:M.mem ->
      ?m_post:M.mem ->
      ?x_result:Translate_prop.Create.F.var ->
      unit -> Translate_prop.Create.env
    val bind_formals :
      Kernel_function.t -> 'a list -> 'Cil_datatype.Varinfo.Map.t
    val call_pre :
      Translate_prop.Create.env ->
      Kernel_function.t -> M.value list -> M.mem -> Translate_prop.Create.env
    val call_post :
      Translate_prop.Create.env ->
      Kernel_function.t ->
      M.value list ->
      M.mem ->
      M.mem ->
      Translate_prop.Create.F.var option -> Translate_prop.Create.env
    val call_exit :
      Translate_prop.Create.env ->
      Kernel_function.t ->
      M.value list ->
      M.mem ->
      M.mem -> Translate_prop.Create.F.var -> Translate_prop.Create.env
    type kind =
        Kcint of Ctypes.c_int
      | Kint
      | Kreal
      | Kbool
      | Kptr of Cil_types.typ
      | Kset of Translate_prop.Create.kind
      | Kstruct of Cil_types.compinfo
      | Karray of Ctypes.arrayinfo
      | Kadt of string * Translate_prop.Create.kind list
    val kind_equal :
      Translate_prop.Create.kind -> Translate_prop.Create.kind -> bool
    val pp_kind : Format.formatter -> Translate_prop.Create.kind -> unit
    type data =
        Data of Translate_prop.Create.F.abstract
      | Loc of M.loc
      | Value of M.value
      | Interval of Translate_prop.Create.F.interval
      | Range of Ctypes.c_object * M.loc * Translate_prop.Create.F.interval
      | List of Translate_prop.Create.data list
      | Set of Translate_prop.Create.F.set
    val pp_data : Format.formatter -> Translate_prop.Create.data -> unit
    val data_of_integer :
      Translate_prop.Create.F.integer -> Translate_prop.Create.data
    val data_of_real :
      Translate_prop.Create.F.real -> Translate_prop.Create.data
    val data_of_boolean :
      Translate_prop.Create.F.boolean -> Translate_prop.Create.data
    val integer_of_value : M.value -> M.F.integer
    val real_of_value : M.value -> M.F.real
    val extract_from_data :
      Translate_prop.Create.data -> 'Translate_prop.Create.F.term
    val boolean_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.F.boolean
    val array_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.F.array
    val record_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.F.record
    val urecord_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.F.urecord
    val loc_of_data : Ctypes.c_object -> Translate_prop.Create.data -> M.loc
    val integer_of_data :
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.F.integer
    val real_of_data :
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.F.real
    val set_of : Translate_prop.Create.data -> Translate_prop.Create.F.set
    val list_of :
      Translate_prop.Create.data -> Translate_prop.Create.data list
    val union_data :
      Translate_prop.Create.data ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val union_map :
      ('-> Translate_prop.Create.data) ->
      'a list -> Translate_prop.Create.data
    val term_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.F.abstract
    val neg_interval :
      Translate_prop.Create.F.interval -> Translate_prop.Create.F.interval
    val object_of_pointed : Translate_prop.Create.kind -> Ctypes.c_object
    val kind_of_typ : Cil_types.typ -> Translate_prop.Create.kind
    val kind_of_data :
      Cil_types.typ ->
      Translate_prop.Create.data -> Translate_prop.Create.kind
    val kind_of : Cil_types.logic_type -> Translate_prop.Create.kind
    val typ_of_elements : Cil_types.logic_type -> Cil_types.typ
    val data_rec :
      (Translate_prop.Create.env ->
       Cil_types.term -> Translate_prop.Create.data)
      Pervasives.ref
    val assigned_of_data :
      Ctypes.c_object ->
      M.loc Translate_prop.Create.F.assigned list ->
      Translate_prop.Create.data ->
      M.loc Translate_prop.Create.F.assigned list
    val data_valid :
      M.mem ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.F.pred
    val data_separated :
      M.mem ->
      Ctypes.c_object * Translate_prop.Create.data ->
      Ctypes.c_object * Translate_prop.Create.data ->
      Translate_prop.Create.F.pred
    val data_shift_range :
      Ctypes.c_object ->
      M.loc ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> is_pos:bool -> Translate_prop.Create.data
    val data_index_range :
      Ctypes.c_object ->
      M.loc ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val data_shift :
      Translate_prop.Create.kind ->
      Translate_prop.Create.data ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> is_pos:bool -> Translate_prop.Create.data
    val data_index :
      Ctypes.c_object ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val data_field :
      Translate_prop.Create.kind ->
      Translate_prop.Create.data ->
      Cil_types.fieldinfo -> Translate_prop.Create.data
    val data_startof_set :
      Ctypes.c_object ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val data_startof :
      Ctypes.c_object ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val data_load :
      Translate_prop.Create.env ->
      Cil_types.typ ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val logic_offset :
      Translate_prop.Create.env ->
      Translate_prop.Create.F.abstract ->
      Cil_types.term_offset -> Translate_prop.Create.data
    val loc_offset :
      Translate_prop.Create.env ->
      M.loc -> Ctypes.c_object -> Cil_types.term_offset -> M.loc
    val memory_offset :
      Translate_prop.Create.env ->
      Cil_types.typ ->
      Translate_prop.Create.data ->
      Cil_types.term_offset -> Cil_types.typ * Translate_prop.Create.data
    val gaddress_of_cvar :
      Translate_prop.Create.env ->
      Cil_types.varinfo ->
      Cil_types.term_offset -> Cil_types.typ * Translate_prop.Create.data
    val gaddress_of_ref :
      Translate_prop.Create.env ->
      Cil_datatype.Logic_var.Map.key ->
      Cil_types.term_offset -> Translate_prop.Create.data
    val gaddress_of_mem :
      Translate_prop.Create.env ->
      Cil_types.term ->
      Cil_types.term_offset -> Cil_types.typ * Translate_prop.Create.data
    val gstartof :
      Cil_types.typ * Translate_prop.Create.data ->
      Translate_prop.Create.data
    val gstartof_cvar :
      Translate_prop.Create.env ->
      Cil_types.varinfo ->
      Cil_types.term_offset -> Translate_prop.Create.data
    val gstartof_mem :
      Translate_prop.Create.env ->
      Cil_types.term -> Cil_types.term_offset -> Translate_prop.Create.data
    val gstartof_value :
      Translate_prop.Create.env ->
      Cil_types.typ ->
      M.value -> Cil_types.term_offset -> Translate_prop.Create.data
    val cast :
      Translate_prop.Create.data ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.kind -> Translate_prop.Create.data
    val int_op :
      Cil_types.binop ->
      Translate_prop.Create.F.integer ->
      Translate_prop.Create.F.integer -> Translate_prop.Create.F.integer
    val real_op :
      Cil_types.binop ->
      Translate_prop.Create.F.real ->
      Translate_prop.Create.F.real -> Translate_prop.Create.F.real
    val rel_op : Cil_types.relation -> Cil_types.binop
    val real_cmp :
      Cil_types.binop ->
      Translate_prop.Create.F.real ->
      Translate_prop.Create.F.real -> Translate_prop.Create.F.boolean
    val int_cmp :
      Cil_types.binop ->
      Translate_prop.Create.F.integer ->
      Translate_prop.Create.F.integer -> Translate_prop.Create.F.boolean
    val preal_cmp :
      Cil_types.binop ->
      Translate_prop.Create.F.real ->
      Translate_prop.Create.F.real -> Translate_prop.Create.F.pred
    val pint_cmp :
      Cil_types.binop ->
      Translate_prop.Create.F.integer ->
      Translate_prop.Create.F.integer -> Translate_prop.Create.F.pred
    val ptr_rel :
      Cil_types.binop -> M.loc -> M.loc -> Translate_prop.Create.F.pred
    val ptr_cmp : Cil_types.binop -> M.loc -> M.loc -> M.F.boolean
    val plus :
      Translate_prop.Create.F.integer ->
      Translate_prop.Create.F.integer -> Translate_prop.Create.F.integer
    val plus_interval :
      Translate_prop.Create.F.interval ->
      Translate_prop.Create.F.integer -> Translate_prop.Create.F.interval
    val plus_interval_interval :
      Translate_prop.Create.F.interval ->
      Translate_prop.Create.F.interval -> Translate_prop.Create.data
    val add_integer :
      Translate_prop.Create.kind ->
      Translate_prop.Create.data ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val data_cmp :
      Cil_types.binop ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.F.boolean
    val data_binop :
      Translate_prop.Create.kind ->
      Cil_types.binop ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val data_unop :
      Translate_prop.Create.kind ->
      Cil_types.unop ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.data
    val data_const : Cil_types.constant -> Translate_prop.Create.data
    val data_of_term :
      Translate_prop.Create.env ->
      Cil_types.term -> Translate_prop.Create.data
    val term :
      Translate_prop.Create.env ->
      Cil_types.term -> Translate_prop.Create.F.abstract
    val data_of_assignable :
      Translate_prop.Create.env ->
      Cil_types.term -> Translate_prop.Create.data
    val assigned :
      Translate_prop.Create.env ->
      Cil_types.term -> M.loc Translate_prop.Create.F.assigned list
    val rec_apply_predicate :
      (Translate_prop.Create.env ->
       Cil_types.logic_info ->
       (Cil_types.logic_label * Cil_types.logic_label) list ->
       Cil_types.term list -> Translate_prop.Create.F.pred)
      Pervasives.ref
    val pred_cmp :
      Cil_types.binop ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.F.pred
    val prop :
      Translate_prop.Create.env ->
      Cil_types.predicate Cil_types.named -> Translate_prop.Create.F.pred
    val prop_body :
      Translate_prop.Create.env ->
      Cil_types.predicate Cil_types.named -> Translate_prop.Create.F.pred
    val get_definition :
      (Cil_types.logic_info ->
       Translate_prop.Create.userdef *
       (string *
        (Translate_prop.Create.F.var, Translate_prop.Create.F.abstract,
         Translate_prop.Create.F.pred)
        Formula.item)
       list) ->
      Cil_types.logic_info -> Translate_prop.Create.userdef
    val push_context : string -> Translate_prop.Create.L.context
    val flush_context :
      string ->
      Translate_prop.Create.L.context ->
      Translate_prop.Create.L.F.pred -> Translate_prop.Create.L.F.pred
    val kill_context : string -> Translate_prop.Create.L.context -> unit
    val user_default_label : Cil_types.logic_label list -> Clabels.c_label
    val user_env :
      Cil_types.logic_info ->
      Translate_prop.Create.L.context *
      Translate_prop.Create.user_formal list * Translate_prop.Create.env
    val collect_signature :
      Translate_prop.Create.user_formal list ->
      (Translate_prop.Create.F.var -> bool) ->
      Translate_prop.Create.env -> Translate_prop.Create.user_formal list
    val flatten_formals :
      Translate_prop.Create.user_formal list ->
      Translate_prop.Create.F.var list
    val flatten_references :
      (Translate_prop.Create.F.var * M.formal * string) list ->
      Translate_prop.Create.user_formal list ->
      Translate_prop.Create.F.var list
    val all_filter : Translate_prop.Create.F.var -> bool
    val term_filter :
      'Translate_prop.Create.F.term -> Translate_prop.Create.F.var -> bool
    val pred_filter :
      Translate_prop.Create.F.pred -> Translate_prop.Create.F.var -> bool
    val compile_predicate :
      Cil_types.logic_info ->
      Translate_prop.Create.userdef *
      (string * ('a, 'b, Translate_prop.Create.L.F.pred) Formula.item) list
    val compile_function :
      Cil_types.logic_info ->
      Translate_prop.Create.userdef *
      (string * ('a, 'b, Translate_prop.Create.F.pred) Formula.item) list
    val axiom_env : string -> Translate_prop.Create.env
    val compile_user_axiom :
      '->
      Cil_types.predicate Cil_types.named -> Translate_prop.Create.L.F.pred
    val compile_user_axiom_labels :
      string ->
      Cil_types.logic_label list * Cil_types.predicate Cil_types.named ->
      Translate_prop.Create.axiomlabel
    val compile_and_define :
      ('a, 'b option) Hashtbl.t ->
      '-> '-> ('-> '-> 'b) -> ('-> '-> unit) -> unit
    val add_axiom :
      string ->
      Cil_types.logic_label list ->
      Cil_types.predicate Cil_types.named -> unit
    val bool_of_option : 'a option -> bool
    val apply_formals :
      Translate_prop.Create.env ->
      (Cil_types.logic_label * Cil_types.logic_label) list ->
      Translate_prop.Create.user_formal list ->
      Translate_prop.Create.data list ->
      Translate_prop.Create.F.abstract list
    val apply_references :
      Translate_prop.Create.env ->
      (Cil_types.logic_label * Cil_types.logic_label) list ->
      (Translate_prop.Create.F.var * M.formal * string) list ->
      Translate_prop.Create.data ->
      Translate_prop.Create.user_formal list ->
      Translate_prop.Create.data list ->
      Translate_prop.Create.F.abstract list
    val apply_predicate :
      Translate_prop.Create.env ->
      Cil_types.logic_info ->
      (Cil_types.logic_label * Cil_types.logic_label) list ->
      Cil_types.term list -> Translate_prop.Create.F.pred
    val apply_function :
      Translate_prop.Create.env ->
      Cil_types.logic_info ->
      (Cil_types.logic_label * Cil_types.logic_label) list ->
      Cil_types.term list -> Translate_prop.Create.F.abstract
  end