functor (WpModel : Mwp.S->
  functor
    (Why : sig
             type pred = WpModel.D.F.pred
             val export_goal : Format.formatter -> string -> pred -> unit
             val export_decl :
               Format.formatter -> pred Formula.declaration -> unit
           end->
    functor
      (Coq : sig
               type pred = WpModel.D.F.pred
               val export_goal : Format.formatter -> string -> pred -> unit
               val export_decl :
                 Format.formatter -> pred Formula.declaration -> unit
             end->
      functor
        (Ergo91 : sig
                    type pred = WpModel.D.F.pred
                    val export_goal :
                      Format.formatter -> string -> pred -> unit
                    val export_decl :
                      Format.formatter -> pred Formula.declaration -> unit
                  end->
        functor
          (Ergo92 : sig
                      type pred = WpModel.D.F.pred
                      val export_goal :
                        Format.formatter -> string -> pred -> unit
                      val export_decl :
                        Format.formatter -> pred Formula.declaration -> unit
                    end->
          functor
            (Splitter : sig
                          type pred = WpModel.D.F.pred
                          val split :
                            Mcfg.assigns_method -> pred -> pred Bag.t
                        end->
            functor (Descr : Description->
              sig
                module Me :
                  sig
                    val self : State.t
                    val name : string
                    val kind : State.kind
                    val mark_as_computed : ?project:Project.t -> unit -> unit
                    val is_computed : ?project:Project.t -> unit -> bool
                    module Datatype :
                      sig
                        type 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
                    val howto_marshal :
                      (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
                    type data = Datatype.Unit.t
                    val set : data -> unit
                    val get : unit -> data
                    val clear : unit -> unit
                  end
                module F :
                  sig
                    type 'a term = 'WpModel.D.F.term
                    type pred = WpModel.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 = WpModel.D.F.var
                    type pool = WpModel.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 = WpModel.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 = 'WpModel.D.F.term
                        type pred = WpModel.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 = WpModel.D.F.var
                        type pool = WpModel.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 = WpModel.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 =
                      WpModel.D.interval = {
                      inf : integer option;
                      sup : integer option;
                    }
                    type 'a assigned =
                      'WpModel.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 = WpModel.D.context
                    type bindings = WpModel.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 = WpModel.D.substitution
                    val apply : substitution -> 'F.term -> 'F.term
                    type havoc =
                      WpModel.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 = WpModel.D.Varinfo.H.key
                            type 'a t = 'WpModel.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 = WpModel.D.Varaddr.H.key
                            type 'a t = 'WpModel.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 = WpModel.D.Fieldinfo.H.key
                            type 'a t = 'WpModel.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 = WpModel.D.Compinfo.H.key
                            type 'a t = 'WpModel.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 = WpModel.D.Arrayinfo.H.key
                            type 'a t = 'WpModel.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 = WpModel.D.Logicvar.H.key
                            type 'a t = 'WpModel.D.Logicvar.H.t
                            val create : int -> 'a t
                            val clear : 'a t -> unit
                            val copy : 'a t -> 'a t
                            val add : 'a t -> key -> '-> unit
                            val remove : 'a t -> key -> unit
                            val find : 'a t -> key -> 'a
                            val find_all : 'a t -> key -> 'a list
                            val replace : 'a t -> key -> '-> unit
                            val mem : 'a t -> key -> bool
                            val iter : (key -> '-> unit) -> 'a t -> unit
                            val fold :
                              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                            val length : 'a t -> int
                          end
                        val index : t -> H.key
                        val prefix : string
                        val basename : t -> string
                        val location : t -> Log.source option
                        val pp_title : Format.formatter -> t -> unit
                        val pp_descr : Format.formatter -> t -> unit
                      end
                    module type Indexed =
                      sig
                        type t
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Dindex :
                      functor (I : Identifiable->
                        sig
                          type t = I.t
                          val define : t -> unit
                          val get_definition :
                            t -> F.pred Formula.declaration
                          val on_definition :
                            (t -> F.pred Formula.declaration -> unit) -> unit
                          val get_ind : t -> integer
                        end
                    module Findex :
                      sig
                        type t = Cil_types.fieldinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Xindex :
                      sig
                        type t = Cil_types.varinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Aindex :
                      sig
                        type t = Cil_types.varinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    module Tindex :
                      sig
                        type t = Cil_types.compinfo
                        val define : t -> unit
                        val get_definition : t -> F.pred Formula.declaration
                        val on_definition :
                          (t -> F.pred Formula.declaration -> unit) -> unit
                        val get_ind : t -> integer
                      end
                    val modulo : Ctypes.c_int -> integer -> integer
                    val guard : Ctypes.c_int -> integer -> F.pred
                    val i_convert :
                      Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                    val round : Ctypes.c_float -> real -> real
                    val f_guard : Ctypes.c_float -> real -> F.pred
                    val f_convert :
                      Ctypes.c_float -> Ctypes.c_float -> real -> real
                    val has_type : abstract -> Cil_types.logic_type -> F.pred
                    val get_range_index : array -> interval -> abstract
                    val set_range_index : array -> interval -> array
                    val empty : set
                    val singleton : abstract -> set
                    val union : set -> set -> set
                    val unions : set list -> set
                    val inter : set -> set -> set
                    val remove : set -> set -> set
                    val set_of_list : abstract list -> set
                    val add_set : set -> set -> set
                    val mult_set : set -> set -> set
                    val neg_set : set -> set
                    val interval : interval -> set
                    val equal_pointer_bool : pointer -> pointer -> boolean
                    val lt_pointer_bool : pointer -> pointer -> boolean
                    val le_pointer_bool : pointer -> pointer -> boolean
                    val lt_pointer : pointer -> pointer -> F.pred
                    val le_pointer : pointer -> pointer -> F.pred
                    val minus_pointer : pointer -> pointer -> integer
                    val is_null : pointer -> boolean
                    val null : pointer
                    val tau_of_object : Ctypes.c_object -> Formula.tau
                    val tau_of_ctype : Cil_types.typ -> Formula.tau
                    val int_format : format
                    val real_format : format
                    val pointer_format : format
                    val record_format : format
                    val urecord_format : format
                    val array_format : format -> format
                    val format_of_object : Ctypes.c_object -> format
                    val decode : format -> abstract -> 'F.term
                    val encode : format -> 'F.term -> abstract
                    val acc_field : record -> Cil_types.fieldinfo -> abstract
                    val upd_field :
                      record -> Cil_types.fieldinfo -> abstract -> record
                    val acc_index : array -> integer -> abstract
                    val upd_index : array -> integer -> abstract -> array
                    val equal :
                      Ctypes.c_object -> abstract -> abstract -> F.pred
                    val eq_array :
                      Ctypes.arrayinfo -> array -> array -> F.pred
                    val eq_record :
                      Cil_types.compinfo -> record -> record -> F.pred
                  end
                module CV :
                  sig
                    type t_prop
                    val pretty : Format.formatter -> t_prop -> unit
                    val merge : t_prop -> t_prop -> t_prop
                    val empty : t_prop
                    type t_env
                    val new_env : Db_types.kernel_function -> t_env
                    val add_axiom :
                      WpAnnot.prop_id ->
                      string ->
                      Cil_types.logic_label list ->
                      Cil_types.predicate Cil_types.named -> unit
                    val add_hyp :
                      t_env ->
                      WpAnnot.prop_id ->
                      Cil_types.predicate Cil_types.named -> t_prop -> t_prop
                    val add_goal :
                      t_env ->
                      WpAnnot.prop_id ->
                      Cil_types.predicate Cil_types.named -> t_prop -> t_prop
                    val add_as_hyp : t_env -> t_prop -> t_prop -> t_prop
                    val add_as_goal : t_env -> t_prop -> t_prop -> t_prop
                    val add_assigns :
                      t_env ->
                      WpAnnot.prop_id ->
                      Cil_types.logic_label ->
                      WpAnnot.a_kind ->
                      Cil_types.identified_term Cil_types.assigns list ->
                      t_prop -> t_prop
                    val use_assigns :
                      t_env ->
                      WpAnnot.prop_id ->
                      WpAnnot.a_kind ->
                      Cil_types.identified_term Cil_types.assigns list ->
                      t_prop -> t_prop
                    val assigns_method : unit -> Mcfg.assigns_method
                    val label :
                      t_env -> Cil_types.logic_label -> t_prop -> t_prop
                    val assign :
                      t_env ->
                      Cil_types.lval -> Cil_types.exp -> t_prop -> t_prop
                    val return :
                      t_env -> Cil_types.exp option -> t_prop -> t_prop
                    val test :
                      t_env -> Cil_types.exp -> t_prop -> t_prop -> t_prop
                    val switch :
                      t_env ->
                      Cil_types.exp ->
                      (Cil_types.exp list * t_prop) list -> t_prop -> t_prop
                    val call_normal :
                      t_env ->
                      get_pre:(Db_types.kernel_function ->
                               (WpAnnot.prop_id *
                                Cil_types.predicate Cil_types.named)
                               list) ->
                      get_post:(Db_types.kernel_function ->
                                (WpAnnot.prop_id *
                                 Cil_types.predicate Cil_types.named)
                                list) ->
                      get_assigns:(Db_types.kernel_function ->
                                   Cil_types.identified_term
                                   Cil_types.assigns list) ->
                      Cil_types.stmt ->
                      Cil_types.lval option ->
                      Cil_types.exp -> Cil_types.exp list -> t_prop -> t_prop
                    val call_exit :
                      t_env ->
                      get_pre:(Db_types.kernel_function ->
                               (WpAnnot.prop_id *
                                Cil_types.predicate Cil_types.named)
                               list) ->
                      get_exits:(Db_types.kernel_function ->
                                 (WpAnnot.prop_id *
                                  Cil_types.predicate Cil_types.named)
                                 list) ->
                      get_assigns:(Db_types.kernel_function ->
                                   Cil_types.identified_term
                                   Cil_types.assigns list) ->
                      Cil_types.stmt ->
                      Cil_types.exp -> Cil_types.exp list -> t_prop -> t_prop
                    val scope :
                      t_env ->
                      Cil_types.varinfo list ->
                      Mcfg.scope -> t_prop -> t_prop
                    val build_prop_of_from :
                      t_env -> WpAnnot.t_id_pred list -> t_prop -> t_prop
                    val close : t_env -> t_prop -> t_prop
                    val zip : t_prop -> WpModel.D.F.pred
                  end
                module PO :
                  sig
                    type description = Cfgpropid.Create(CV).description
                    type t_goal =
                      Cfgpropid.Create(CV).t_goal = {
                      g_id : WpAnnot.prop_id;
                      g_prop : CV.t_prop;
                      g_descr : description;
                    }
                    val pp_goal :
                      Format.formatter -> string -> t_goal -> unit
                    val pp_descr : Format.formatter -> t_goal -> unit
                    val iter_description :
                      (Wpo.warning -> unit) ->
                      (Wpo.dependency -> unit) -> description -> unit
                    type t_prop = t_goal list
                    val pretty : Format.formatter -> t_prop -> unit
                    val merge : t_prop -> t_prop -> t_prop
                    val empty : t_prop
                    type t_env = Cfgpropid.Create(CV).t_env
                    val new_env : Db_types.kernel_function -> t_env
                    val add_axiom :
                      WpAnnot.prop_id ->
                      string ->
                      Cil_types.logic_label list ->
                      Cil_types.predicate Cil_types.named -> unit
                    val add_hyp :
                      t_env ->
                      WpAnnot.prop_id ->
                      Cil_types.predicate Cil_types.named -> t_prop -> t_prop
                    val add_goal :
                      t_env ->
                      WpAnnot.prop_id ->
                      Cil_types.predicate Cil_types.named -> t_prop -> t_prop
                    val add_as_hyp : t_env -> t_prop -> t_prop -> t_prop
                    val add_as_goal : t_env -> t_prop -> t_prop -> t_prop
                    val add_assigns :
                      t_env ->
                      WpAnnot.prop_id ->
                      Cil_types.logic_label ->
                      WpAnnot.a_kind ->
                      Cil_types.identified_term Cil_types.assigns list ->
                      t_prop -> t_prop
                    val use_assigns :
                      t_env ->
                      WpAnnot.prop_id ->
                      WpAnnot.a_kind ->
                      Cil_types.identified_term Cil_types.assigns list ->
                      t_prop -> t_prop
                    val assigns_method : unit -> Mcfg.assigns_method
                    val label :
                      t_env -> Cil_types.logic_label -> t_prop -> t_prop
                    val assign :
                      t_env ->
                      Cil_types.lval -> Cil_types.exp -> t_prop -> t_prop
                    val return :
                      t_env -> Cil_types.exp option -> t_prop -> t_prop
                    val test :
                      t_env -> Cil_types.exp -> t_prop -> t_prop -> t_prop
                    val switch :
                      t_env ->
                      Cil_types.exp ->
                      (Cil_types.exp list * t_prop) list -> t_prop -> t_prop
                    val call_normal :
                      t_env ->
                      get_pre:(Db_types.kernel_function ->
                               (WpAnnot.prop_id *
                                Cil_types.predicate Cil_types.named)
                               list) ->
                      get_post:(Db_types.kernel_function ->
                                (WpAnnot.prop_id *
                                 Cil_types.predicate Cil_types.named)
                                list) ->
                      get_assigns:(Db_types.kernel_function ->
                                   Cil_types.identified_term
                                   Cil_types.assigns list) ->
                      Cil_types.stmt ->
                      Cil_types.lval option ->
                      Cil_types.exp -> Cil_types.exp list -> t_prop -> t_prop
                    val call_exit :
                      t_env ->
                      get_pre:(Db_types.kernel_function ->
                               (WpAnnot.prop_id *
                                Cil_types.predicate Cil_types.named)
                               list) ->
                      get_exits:(Db_types.kernel_function ->
                                 (WpAnnot.prop_id *
                                  Cil_types.predicate Cil_types.named)
                                 list) ->
                      get_assigns:(Db_types.kernel_function ->
                                   Cil_types.identified_term
                                   Cil_types.assigns list) ->
                      Cil_types.stmt ->
                      Cil_types.exp -> Cil_types.exp list -> t_prop -> t_prop
                    val scope :
                      t_env ->
                      Cil_types.varinfo list ->
                      Mcfg.scope -> t_prop -> t_prop
                    val build_prop_of_from :
                      t_env -> WpAnnot.t_id_pred list -> t_prop -> t_prop
                    val close : t_env -> t_prop -> t_prop
                  end
                module WP :
                  sig
                    val compute :
                      Cil2cfg.t ->
                      WpAnnot.strategy ->
                      PO.t_prop list *
                      (Format.formatter -> Cil2cfg.edge -> unit)
                  end
                module ST :
                  sig
                    val set :
                      Property.t ->
                      Property.t list -> Cil_types.annotation_status -> unit
                    val update :
                      Property.t ->
                      Property.t list ->
                      (Cil_types.annotation_status ->
                       Cil_types.annotation_status) ->
                      Cil_types.annotation_status
                  end
                type exportation = {
                  env : string;
                  mutable goals : Wpo.t list;
                }
                val assigns_method : unit -> Mcfg.assigns_method
                val export_wpo :
                  CfgProof.Create.exportation ->
                  Db_types.kernel_function ->
                  string option ->
                  Wpo.warning list ->
                  Wpo.dependency list ->
                  WpAnnot.prop_id -> CfgProof.Create.F.pred -> unit
                val build_wpos :
                  CfgProof.Create.exportation ->
                  Db_types.kernel_function ->
                  string option ->
                  Wpo.warning list ->
                  Wpo.dependency list ->
                  WpAnnot.prop_id -> Splitter.pred -> unit
                val add_goal :
                  CfgProof.Create.exportation ->
                  Db_types.kernel_function ->
                  string option -> CfgProof.Create.PO.t_goal -> unit
                class computer :
                  object
                    val mutable exported : 'a option
                    val mutable wptasks :
                      (Cil2cfg.t * WpAnnot.strategy list) list
                    method add : Cil2cfg.t -> WpAnnot.strategy list -> unit
                    method compute : Wpo.t list
                  end
                val create : unit -> CfgProof.Create.computer
              end