functor (M : Mlogic.S->
  sig
    module F :
      sig
        type 'a term = 'M.D.F.term
        type pred = M.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 = M.D.F.var
        type pool = M.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 = M.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 D :
      sig
        module F :
          sig
            type 'a term = 'M.D.F.term
            type pred = M.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 = M.D.F.var
            type pool = M.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 = M.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 =
          M.D.interval = {
          inf : integer option;
          sup : integer option;
        }
        type 'a assigned =
          'M.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 = M.D.context
        type bindings = M.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 = M.D.substitution
        val apply : substitution -> 'F.term -> 'F.term
        type havoc =
          M.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 = M.D.Varinfo.H.key
                type 'a t = 'M.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 = M.D.Varaddr.H.key
                type 'a t = 'M.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 = M.D.Fieldinfo.H.key
                type 'a t = 'M.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 = M.D.Compinfo.H.key
                type 'a t = 'M.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 = M.D.Arrayinfo.H.key
                type 'a t = 'M.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 = M.D.Logicvar.H.key
                type 'a t = 'M.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
    type userdef = {
      d_info : Cil_types.logic_info;
      d_callname : string;
      d_implicit : Translate_prop.Create.F.var list;
      d_closure : M.closure list;
      d_formals : Translate_prop.Create.F.var list;
    }
    type axiomdef = {
      a_name : string;
      a_labels : string list;
      a_hyp_name : string;
      a_def_name : string;
      a_implicit : Translate_prop.Create.F.var list;
      a_closure : M.closure list;
      a_property : Translate_prop.Create.F.pred;
    }
    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
        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.D.F.pred) Hashtbl.t
    val user_axiomdefs :
      (string, Translate_prop.Create.axiomdef option) Hashtbl.t
    val user_variables :
      Formula.abstract Translate_prop.Create.F.term
      Translate_prop.Create.Hdef.t
    val user_definitions :
      (Translate_prop.Create.userdef *
       (string * Translate_prop.Create.D.F.pred Formula.item) list)
      Translate_prop.Create.Hdef.t
    module UserVariable :
      sig
        type t = Cil_types.logic_var
        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
    val get_user_variable :
      Translate_prop.Create.Hdef.key ->
      Formula.abstract Translate_prop.Create.F.term
    val pp_closures :
      Format.formatter ->
      Translate_prop.Create.F.var list -> M.closure list -> unit
    val pp_formals :
      Format.formatter -> Translate_prop.Create.F.var list -> unit
    module UserAxiom :
      sig
        type t = string
        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
    module UserDefinition :
      sig
        val index : unit Translate_prop.Create.Hdef.t
        val pp_userdef_title :
          Format.formatter -> Translate_prop.Create.userdef -> unit
        val pp_userdef_descr :
          Format.formatter -> Translate_prop.Create.userdef -> unit
        val define :
          Translate_prop.Create.userdef ->
          (string * Translate_prop.Create.D.F.pred Formula.item) list -> unit
      end
    module UserAxiomDefs :
      sig
        val index : (string, unit) Hashtbl.t
        val pp_axiomdef_title :
          Format.formatter -> Translate_prop.Create.axiomdef -> unit
        val pp_axiomdef_descr :
          Format.formatter -> Translate_prop.Create.axiomdef -> unit
        val define : Translate_prop.Create.axiomdef -> unit
      end
    type xvar = PrmVar of M.value | MemVar
    type env = {
      formals_in_pre : bool;
      frame : M.frame;
      label : Clabels.c_label;
      lvars :
        Formula.abstract Translate_prop.Create.F.term
        Cil_datatype.Logic_var.Map.t;
      xvars : M.value Cil_datatype.Varinfo.Map.t;
    }
    val env_at :
      Translate_prop.Create.env ->
      Clabels.c_label -> Translate_prop.Create.env
    val get_frame : Translate_prop.Create.env -> M.frame
    val mem_at_env : Translate_prop.Create.env -> M.mem
    val quant_env :
      Translate_prop.Create.env ->
      (Cil_datatype.Logic_var.Map.key *
       Formula.abstract Translate_prop.Create.F.term)
      list -> Translate_prop.Create.env
    val env_body : M.frame -> Translate_prop.Create.env
    val call_post :
      Kernel_function.t ->
      M.value list ->
      M.mem -> M.mem -> M.D.F.var option -> Translate_prop.Create.env
    val call_pre :
      Kernel_function.t -> M.value list -> M.mem -> Translate_prop.Create.env
    val call_exit :
      Translate_prop.Create.env -> M.D.F.var -> Translate_prop.Create.env
    val assigns_clause : M.frame -> Translate_prop.Create.env
    val lvar :
      Formula.abstract Translate_prop.Create.F.term
      Cil_datatype.Logic_var.Map.t ->
      Cil_datatype.Logic_var.Map.key ->
      Formula.abstract Translate_prop.Create.F.term
    val add_lvar :
      Translate_prop.Create.env ->
      Cil_datatype.Logic_var.Map.key ->
      Formula.abstract Translate_prop.Create.F.term ->
      Translate_prop.Create.env
    val xvar_of_varinfo :
      Translate_prop.Create.env ->
      Cil_datatype.Varinfo.Map.key -> Translate_prop.Create.xvar
    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 pp_kind : Format.formatter -> Translate_prop.Create.kind -> unit
    type data =
        Data of Formula.abstract Translate_prop.Create.F.term
      | Loc of M.loc
      | Value of M.value
      | Interval of Translate_prop.Create.D.interval
      | Range of Ctypes.c_object * M.loc * Translate_prop.Create.D.interval
      | List of Translate_prop.Create.data list
      | Set of Translate_prop.Create.D.set
    val pp_data : Format.formatter -> Translate_prop.Create.data -> unit
    val data_of_integer :
      Formula.integer Translate_prop.Create.F.term ->
      Translate_prop.Create.data
    val data_of_real :
      Formula.real Translate_prop.Create.F.term -> Translate_prop.Create.data
    val data_of_boolean :
      Formula.boolean Translate_prop.Create.F.term ->
      Translate_prop.Create.data
    val integer_of_value : M.value -> M.D.integer
    val real_of_value : M.value -> M.D.real
    val extract_from_data :
      Translate_prop.Create.data -> 'Translate_prop.Create.F.term
    val boolean_of_data :
      Translate_prop.Create.data ->
      Formula.boolean Translate_prop.Create.F.term
    val array_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.D.array
    val record_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.D.record
    val urecord_of_data :
      Translate_prop.Create.data -> Translate_prop.Create.D.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 ->
      Formula.integer Translate_prop.Create.F.term
    val real_of_data :
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Formula.real Translate_prop.Create.F.term
    val set_of : Translate_prop.Create.data -> Translate_prop.Create.D.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 ->
      Formula.abstract Translate_prop.Create.F.term
    val neg_interval :
      Translate_prop.Create.D.interval -> Translate_prop.Create.D.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 rec_apply_function :
      (Translate_prop.Create.env ->
       Cil_types.logic_info ->
       (Cil_types.logic_label * Cil_types.logic_label) list ->
       Cil_types.term list -> Formula.abstract Translate_prop.Create.F.term)
      Pervasives.ref
    val assigned_of_data :
      Ctypes.c_object ->
      M.loc Translate_prop.Create.D.assigned list ->
      Translate_prop.Create.data ->
      M.loc Translate_prop.Create.D.assigned list
    val data_valid :
      M.mem ->
      Translate_prop.Create.kind ->
      Translate_prop.Create.data -> Translate_prop.Create.F.pred
    val data_separated :
      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 ->
      Formula.abstract Translate_prop.Create.F.term ->
      Cil_types.term_offset -> Translate_prop.Create.data
    val loc_offset :
      Translate_prop.Create.env ->
      M.loc -> Cil_types.typ -> 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_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 ->
      Formula.integer Translate_prop.Create.F.term ->
      Formula.integer Translate_prop.Create.F.term ->
      Formula.integer Translate_prop.Create.F.term
    val real_op :
      Cil_types.binop ->
      Formula.real Translate_prop.Create.F.term ->
      Formula.real Translate_prop.Create.F.term ->
      Formula.real Translate_prop.Create.F.term
    val rel_op : Cil_types.relation -> Cil_types.binop
    val real_cmp :
      Cil_types.binop ->
      Formula.real Translate_prop.Create.F.term ->
      Formula.real Translate_prop.Create.F.term ->
      Formula.boolean Translate_prop.Create.F.term
    val int_cmp :
      Cil_types.binop ->
      Formula.integer Translate_prop.Create.F.term ->
      Formula.integer Translate_prop.Create.F.term ->
      Formula.boolean Translate_prop.Create.F.term
    val preal_cmp :
      Cil_types.binop ->
      Formula.real Translate_prop.Create.F.term ->
      Formula.real Translate_prop.Create.F.term ->
      Translate_prop.Create.F.pred
    val pint_cmp :
      Cil_types.binop ->
      Formula.integer Translate_prop.Create.F.term ->
      Formula.integer Translate_prop.Create.F.term ->
      Translate_prop.Create.F.pred
    val ptr_rel :
      Cil_types.binop ->
      Translate_prop.Create.D.pointer ->
      Translate_prop.Create.D.pointer -> Translate_prop.Create.D.F.pred
    val ptr_cmp :
      Cil_types.binop ->
      Translate_prop.Create.D.pointer ->
      Translate_prop.Create.D.pointer -> Translate_prop.Create.D.boolean
    val plus :
      Formula.integer Translate_prop.Create.F.term ->
      Formula.integer Translate_prop.Create.F.term ->
      Formula.integer Translate_prop.Create.F.term
    val plus_interval :
      Translate_prop.Create.D.interval ->
      Formula.integer Translate_prop.Create.F.term ->
      Translate_prop.Create.D.interval
    val plus_interval_interval :
      Translate_prop.Create.D.interval ->
      Translate_prop.Create.D.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 ->
      Formula.boolean Translate_prop.Create.F.term
    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 -> Formula.abstract Translate_prop.Create.F.term
    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.D.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_axiom : string -> Translate_prop.Create.axiomdef option
    type partial =
        Svalue of Formula.abstract Translate_prop.Create.F.term
      | Sclosure of M.closure
    val hints : int Pervasives.ref
    val pp_partial :
      Format.formatter -> Translate_prop.Create.partial -> unit
    val apply_sigma :
      Translate_prop.Create.env ->
      (string * Clabels.c_label) list ->
      M.closure -> Translate_prop.Create.partial
    class instance :
      Translate_prop.Create.axiomdef ->
      Translate_prop.Create.partial list ->
      object
        val axdef : Translate_prop.Create.axiomdef
        val mutable captured : bool
        val mutable id : int
        val mutable partials : Translate_prop.Create.partial list
        method alive : bool
        method capture : Translate_prop.Create.F.var list -> unit
        method extend_with_hint :
          Translate_prop.Create.env ->
          Axiomatics.hint -> Translate_prop.Create.instance option
        method has_var : Translate_prop.Create.F.var list -> bool
        method id : int
        method instantiate : Translate_prop.Create.F.pred option
        method pretty : Format.formatter -> unit
        method subst :
          Translate_prop.Create.F.var ->
          Formula.abstract Translate_prop.Create.F.term -> unit
      end
    val instance_of_hint :
      Translate_prop.Create.env ->
      Axiomatics.hint -> Translate_prop.Create.instance option
    val saturate :
      Translate_prop.Create.instance list ->
      Translate_prop.Create.env ->
      Axiomatics.hint list -> Translate_prop.Create.instance list
    val hint_context :
      Translate_prop.Create.instance list option Pervasives.ref
    val push_instances :
      string -> Translate_prop.Create.instance list -> unit
    val pop_instances : string -> Translate_prop.Create.instance list
    val apply_hints :
      Translate_prop.Create.env ->
      Cil_types.logic_info ->
      (Cil_types.logic_label * Cil_types.logic_label) list -> unit
    val do_instantiate :
      (< alive : bool; instantiate : Translate_prop.Create.F.pred option;
         .. >
       as 'a)
      list ->
      Translate_prop.Create.F.pred ->
      'a list -> 'a list * Translate_prop.Create.F.pred
    val instantiate :
      (< alive : bool; instantiate : Translate_prop.Create.F.pred option;
         .. >
       as 'a)
      list ->
      Translate_prop.Create.F.pred -> 'a list * Translate_prop.Create.F.pred
    val as_hint :
      Translate_prop.Create.instance -> Translate_prop.Create.D.hint
    val merge :
      (< alive : bool; id : Datatype.Int.t; .. > as 'a) list ->
      'a list -> 'a list
    val get_definition :
      (Cil_types.logic_info ->
       Translate_prop.Create.userdef *
       (string * Translate_prop.Create.D.F.pred Formula.item) list) ->
      Cil_types.logic_info -> Translate_prop.Create.userdef
    val push_context :
      string ->
      Translate_prop.Create.instance list option *
      Translate_prop.Create.D.context
    val flush_context :
      string ->
      Translate_prop.Create.instance list option *
      Translate_prop.Create.D.context ->
      Translate_prop.Create.D.F.pred -> Translate_prop.Create.D.F.pred
    val kill_context :
      string ->
      Translate_prop.Create.instance list option *
      Translate_prop.Create.D.context -> unit
    val user_env :
      Cil_types.logic_info ->
      (Translate_prop.Create.instance list option *
       Translate_prop.Create.D.context) *
      (Cil_types.logic_var * Translate_prop.Create.D.F.var) list *
      Translate_prop.Create.env
    val compile_predicate :
      Cil_types.logic_info ->
      Translate_prop.Create.userdef *
      (string * Translate_prop.Create.D.F.pred Formula.item) list
    val compile_function :
      Cil_types.logic_info ->
      Translate_prop.Create.userdef *
      (string * Translate_prop.Create.F.pred Formula.item) list
    val axiom_env : string -> Translate_prop.Create.env
    val compile_user_axiom :
      string -> Cil_types.predicate Cil_types.named -> unit
    val compile_user_hypothesis :
      string ->
      Cil_types.logic_label list ->
      Cil_types.predicate Cil_types.named -> unit
    val add_axiom :
      string ->
      Cil_types.logic_label list ->
      Cil_types.predicate Cil_types.named -> unit
    val apply_closure :
      Translate_prop.Create.env ->
      (Cil_types.logic_label * Cil_types.logic_label) list ->
      M.closure -> Formula.abstract M.D.F.term
    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 -> Formula.abstract Translate_prop.Create.F.term
  end