functor (WpModel : Mwp.S->
  functor
    (Why : sig
             type pred = WpModel.F.pred
             type decl = WpModel.F.decl
             val export_section : Format.formatter -> string -> unit
             val export_goal : Format.formatter -> string -> pred -> unit
             val export_decl : Format.formatter -> decl -> unit
           end->
    functor
      (Coq : sig
               type pred = WpModel.F.pred
               type decl = WpModel.F.decl
               val export_section : Format.formatter -> string -> unit
               val export_goal : Format.formatter -> string -> pred -> unit
               val export_decl : Format.formatter -> decl -> unit
             end->
      functor
        (Ergo : sig
                  type pred = WpModel.F.pred
                  type decl = WpModel.F.decl
                  val export_section : Format.formatter -> string -> unit
                  val export_goal :
                    Format.formatter -> string -> pred -> unit
                  val export_decl : Format.formatter -> decl -> unit
                end->
        functor
          (Splitter : sig
                        type pred = WpModel.F.pred
                        val simplify : pred -> 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 : Datatype.S
                  val add_hook_on_update : (Datatype.t -> unit) -> unit
                  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 var = WpModel.F.var
                  type 'a term = 'WpModel.F.term
                  type pred = WpModel.F.pred
                  type abstract = Formula.m_abstract term
                  type integer = Formula.m_integer term
                  type real = Formula.m_real term
                  type boolean = Formula.m_boolean term
                  type record = Formula.m_record term
                  type urecord = Formula.m_array term
                  type array = Formula.m_array term
                  type set = Formula.m_set term
                  type name = Formula.m_integer term
                  type decl = (var, abstract, pred) Formula.declaration
                  val e_int : int -> integer
                  val e_call : string -> abstract list -> abstract
                  val p_call : string -> abstract list -> pred
                  val wrap : 'a term -> abstract
                  val unwrap : abstract -> 'a term
                  val clear : unit -> unit
                  val on_clear : (unit -> unit) -> unit
                  val fresh_name : string -> string -> string
                  val add_declaration : decl -> unit
                  val has_declaration : string -> bool
                  val iter_all : (string -> unit) -> (decl -> unit) -> unit
                  module type Identifiable =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module type Registry =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                    end
                  module type Declarator =
                    sig
                      type t
                      module H : Hashtbl.S
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                      val clear : unit -> unit
                      val section : Formula.section
                      val declare :
                        t -> string -> (var, abstract, pred) Formula.item
                    end
                  module DRegister :
                    functor (D : Declarator->
                      sig
                        type t = D.t
                        val define : t -> unit
                        val get_definition : t -> decl
                        val on_definition : (t -> decl -> unit) -> unit
                      end
                  module Varinfo :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = WpModel.F.Varinfo.H.key
                          type 'a t = 'WpModel.F.Varinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Varaddr :
                    sig
                      type t = Cil_types.varinfo
                      module H :
                        sig
                          type key = WpModel.F.Varaddr.H.key
                          type 'a t = 'WpModel.F.Varaddr.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Fieldinfo :
                    sig
                      type t = Cil_types.fieldinfo
                      module H :
                        sig
                          type key = WpModel.F.Fieldinfo.H.key
                          type 'a t = 'WpModel.F.Fieldinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Compinfo :
                    sig
                      type t = Cil_types.compinfo
                      module H :
                        sig
                          type key = WpModel.F.Compinfo.H.key
                          type 'a t = 'WpModel.F.Compinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Arrayinfo :
                    sig
                      type t = Ctypes.arrayinfo
                      module H :
                        sig
                          type key = WpModel.F.Arrayinfo.H.key
                          type 'a t = 'WpModel.F.Arrayinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Logicvar :
                    sig
                      type t = Cil_types.logic_var
                      module H :
                        sig
                          type key = WpModel.F.Logicvar.H.key
                          type 'a t = 'WpModel.F.Logicvar.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module LTypeinfo :
                    sig
                      type t = Cil_types.logic_type
                      module H :
                        sig
                          type key = WpModel.F.LTypeinfo.H.key
                          type 'a t = 'WpModel.F.LTypeinfo.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module Cobject :
                    sig
                      type t = Ctypes.c_object
                      module H :
                        sig
                          type key = WpModel.F.Cobject.H.key
                          type 'a t = 'WpModel.F.Cobject.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  module ArrayDim :
                    sig
                      type t = Ctypes.c_object * int
                      module H :
                        sig
                          type key = WpModel.F.ArrayDim.H.key
                          type 'a t = 'WpModel.F.ArrayDim.H.t
                          val create : int -> 'a t
                          val clear : 'a t -> unit
                          val copy : 'a t -> 'a t
                          val add : 'a t -> key -> '-> unit
                          val remove : 'a t -> key -> unit
                          val find : 'a t -> key -> 'a
                          val find_all : 'a t -> key -> 'a list
                          val replace : 'a t -> key -> '-> unit
                          val mem : 'a t -> key -> bool
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val length : 'a t -> int
                        end
                      val index : t -> H.key
                      val prefix : string
                      val basename : t -> string
                      val location : t -> Lexing.position option
                      val pp_title : Format.formatter -> t -> unit
                      val pp_descr : Format.formatter -> t -> unit
                    end
                  val adt_decl : Cil_types.logic_type_info -> string
                  val pp_tau : Format.formatter -> Formula.tau -> unit
                  val e_true : boolean
                  val e_false : boolean
                  val e_float : float -> real
                  val e_icst : string -> integer
                  val e_rcst : string -> real
                  val e_int64 : int64 -> integer
                  val e_ineg : integer -> integer
                  val e_rneg : real -> real
                  val e_iop : Formula.int_op -> integer -> integer -> integer
                  val e_rop : Formula.real_op -> real -> real -> real
                  val e_icmp :
                    Formula.cmp_op -> integer -> integer -> boolean
                  val e_rcmp : Formula.cmp_op -> real -> real -> boolean
                  val p_icmp : Formula.cmp_op -> integer -> integer -> pred
                  val p_rcmp : Formula.cmp_op -> real -> real -> pred
                  val e_bnot : integer -> integer
                  val e_band : integer -> integer -> integer
                  val e_bor : integer -> integer -> integer
                  val e_bxor : integer -> integer -> integer
                  val e_lshift : integer -> integer -> integer
                  val e_rshift : integer -> integer -> integer
                  val integer_of_real : real -> integer
                  val real_of_integer : integer -> real
                  val e_bool : boolean -> integer
                  val e_not : boolean -> boolean
                  val e_and : boolean -> boolean -> boolean
                  val e_or : boolean -> boolean -> boolean
                  val e_cond : boolean -> 'a term -> 'a term -> 'a term
                  val p_cond : boolean -> pred -> pred -> pred
                  val e_getfield : Cil_types.fieldinfo -> record -> abstract
                  val e_setfield :
                    Cil_types.fieldinfo -> record -> abstract -> record
                  val e_access : array -> integer -> abstract
                  val e_update : array -> integer -> abstract -> array
                  val p_true : pred
                  val p_false : pred
                  val p_bool : boolean -> pred
                  val p_and : pred -> pred -> pred
                  val p_or : pred -> pred -> pred
                  val p_xor : pred -> pred -> pred
                  val p_not : pred -> pred
                  val p_implies : pred -> pred -> pred
                  val p_iff : pred -> pred -> pred
                  val p_eq : 'a term -> 'a term -> pred
                  val p_neq : 'a term -> 'a term -> pred
                  val p_conj : pred list -> pred
                  val p_disj : pred list -> pred
                  val p_named : string -> pred -> pred
                  val is_true : pred -> bool
                  val is_false : pred -> bool
                  val huge_term : int -> 'a term -> bool
                  val huge_pred : int -> pred -> bool
                  type pool = WpModel.F.pool
                  val pool : unit -> pool
                  val p_fresh : pool -> string -> Formula.kind -> var
                  val p_freshen : pool -> var -> var
                  val var : var -> 'a term
                  val eq_var : var -> var -> bool
                  val name_of_var : var -> string
                  val basename_of_var : var -> string
                  val tau_of_var : var -> Formula.tau
                  val kind_of_var : var -> Formula.kind
                  val term_has_var : var list -> 'a term -> bool
                  val pred_has_var : var list -> pred -> bool
                  val term_calls : string -> 'a term -> bool
                  val pred_calls : string -> pred -> bool
                  val term_closed : 'a term -> bool
                  val pred_closed : pred -> bool
                  val freevars : pred -> var list
                  val p_forall : var list -> pred -> pred
                  val p_exists : var list -> pred -> pred
                  val p_subst :
                    (var -> var option) -> var -> 'a term -> pred -> pred
                  val e_subst :
                    (var -> var option) ->
                    var -> 'a term -> 'b term -> 'b term
                  val e_rename : (var * var) list -> 'a term -> 'a term
                  val equal_terms : 'a term -> 'a term -> bool
                  type alpha = WpModel.F.alpha
                  val empty_alpha : alpha
                  val fold_alpha :
                    (var -> var -> '-> 'a) -> alpha -> '-> 'a
                  val p_more_alpha_cv : alpha -> pred -> alpha * pred
                  val p_alpha_cv : pred -> var list * pred
                  val pp_var : Format.formatter -> var -> unit
                  val pp_section : Format.formatter -> string -> unit
                  val pp_term : Format.formatter -> 'a term -> unit
                  val pp_pred : Format.formatter -> pred -> unit
                  val pp_decl : Format.formatter -> decl -> unit
                  val pp_goal : Format.formatter -> string -> pred -> unit
                  val pp_vkind : Format.formatter -> Formula.kind -> unit
                  val e_app0 : string -> 'a term
                  val e_app1 : string -> 'a term -> 'b term
                  val e_app2 : string -> 'a term -> 'b term -> 'c term
                  val e_app3 :
                    string -> 'a term -> 'b term -> 'c term -> 'd term
                  val e_app4 :
                    string ->
                    'a term -> 'b term -> 'c term -> 'd term -> 'e term
                  val e_app5 :
                    string ->
                    'a term ->
                    'b term -> 'c term -> 'd term -> 'e term -> 'f term
                  val p_app0 : string -> pred
                  val p_app1 : string -> 'a term -> pred
                  val p_app2 : string -> 'a term -> 'b term -> pred
                  val p_app3 :
                    string -> 'a term -> 'b term -> 'c term -> pred
                  val p_app4 :
                    string ->
                    'a term -> 'b term -> 'c term -> 'd term -> pred
                  val p_app5 :
                    string ->
                    'a term ->
                    'b term -> 'c term -> 'd term -> 'e term -> pred
                  val dummy : unit -> pred
                  val i_zero : integer
                  val r_zero : real
                  val i_one : integer
                  val i_add : integer -> integer -> integer
                  val i_mult : integer -> integer -> integer
                  val i_sub : integer -> integer -> integer
                  val guard : Ctypes.c_int -> integer -> pred
                  val modulo : Ctypes.c_int -> integer -> integer
                  val i_convert :
                    Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                  type interval =
                    WpModel.F.interval = {
                    inf : integer option;
                    sup : integer option;
                  }
                  type 'a assigned =
                    'WpModel.F.assigned =
                      Aloc of Ctypes.c_object * 'a
                    | Arange of Ctypes.c_object * 'a * interval
                  type havoc =
                    WpModel.F.havoc =
                      Fresh of var
                    | Update of var * ((var * var) list -> abstract)
                  val pp_interval : Format.formatter -> interval -> unit
                  val set_range_index : array -> interval -> array
                  val empty : set
                  val singleton : abstract -> set
                  val union : set -> set -> set
                  val unions : set list -> set
                  val inter : set -> set -> set
                  val remove : set -> set -> set
                  val set_of_list : abstract list -> set
                  val add_set : set -> set -> set
                  val mult_set : set -> set -> set
                  val neg_set : set -> set
                  val interval : interval -> set
                  val acc_field : record -> Cil_types.fieldinfo -> abstract
                  val upd_field :
                    record -> Cil_types.fieldinfo -> abstract -> record
                  val acc_index : array -> integer -> abstract
                  val upd_index : array -> integer -> abstract -> array
                  module type Indexed =
                    sig
                      type t
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Dindex :
                    functor (I : Identifiable->
                      sig
                        type t = I.t
                        val define : t -> unit
                        val get_definition : t -> decl
                        val on_definition : (t -> decl -> unit) -> unit
                        val get_ind : t -> integer
                        val has_ind : t -> pred -> bool
                      end
                  module Findex :
                    sig
                      type t = Cil_types.fieldinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Xindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Aindex :
                    sig
                      type t = Cil_types.varinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module Tindex :
                    sig
                      type t = Cil_types.compinfo
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                  module LTindex :
                    sig
                      type t = Cil_types.logic_type
                      val define : t -> unit
                      val get_definition : t -> decl
                      val on_definition : (t -> decl -> unit) -> unit
                      val get_ind : t -> integer
                      val has_ind : t -> pred -> bool
                    end
                end
              module L :
                sig
                  module F :
                    sig
                      type var = WpModel.F.var
                      type 'a term = 'WpModel.F.term
                      type pred = WpModel.F.pred
                      type abstract = Formula.m_abstract term
                      type integer = Formula.m_integer term
                      type real = Formula.m_real term
                      type boolean = Formula.m_boolean term
                      type record = Formula.m_record term
                      type urecord = Formula.m_array term
                      type array = Formula.m_array term
                      type set = Formula.m_set term
                      type name = Formula.m_integer term
                      type decl = (var, abstract, pred) Formula.declaration
                      val e_int : int -> integer
                      val e_call : string -> abstract list -> abstract
                      val p_call : string -> abstract list -> pred
                      val wrap : 'a term -> abstract
                      val unwrap : abstract -> 'a term
                      val clear : unit -> unit
                      val on_clear : (unit -> unit) -> unit
                      val fresh_name : string -> string -> string
                      val add_declaration : decl -> unit
                      val has_declaration : string -> bool
                      val iter_all :
                        (string -> unit) -> (decl -> unit) -> unit
                      module type Identifiable =
                        sig
                          type t
                          module H : Hashtbl.S
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module type Registry =
                        sig
                          type t
                          val define : t -> unit
                          val get_definition : t -> decl
                          val on_definition : (t -> decl -> unit) -> unit
                        end
                      module type Declarator =
                        sig
                          type t
                          module H : Hashtbl.S
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                          val clear : unit -> unit
                          val section : Formula.section
                          val declare :
                            t -> string -> (var, abstract, pred) Formula.item
                        end
                      module DRegister :
                        functor (D : Declarator->
                          sig
                            type t = D.t
                            val define : t -> unit
                            val get_definition : t -> decl
                            val on_definition : (t -> decl -> unit) -> unit
                          end
                      module Varinfo :
                        sig
                          type t = Cil_types.varinfo
                          module H :
                            sig
                              type key = WpModel.F.Varinfo.H.key
                              type 'a t = 'WpModel.F.Varinfo.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module Varaddr :
                        sig
                          type t = Cil_types.varinfo
                          module H :
                            sig
                              type key = WpModel.F.Varaddr.H.key
                              type 'a t = 'WpModel.F.Varaddr.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module Fieldinfo :
                        sig
                          type t = Cil_types.fieldinfo
                          module H :
                            sig
                              type key = WpModel.F.Fieldinfo.H.key
                              type 'a t = 'WpModel.F.Fieldinfo.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module Compinfo :
                        sig
                          type t = Cil_types.compinfo
                          module H :
                            sig
                              type key = WpModel.F.Compinfo.H.key
                              type 'a t = 'WpModel.F.Compinfo.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module Arrayinfo :
                        sig
                          type t = Ctypes.arrayinfo
                          module H :
                            sig
                              type key = WpModel.F.Arrayinfo.H.key
                              type 'a t = 'WpModel.F.Arrayinfo.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module Logicvar :
                        sig
                          type t = Cil_types.logic_var
                          module H :
                            sig
                              type key = WpModel.F.Logicvar.H.key
                              type 'a t = 'WpModel.F.Logicvar.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module LTypeinfo :
                        sig
                          type t = Cil_types.logic_type
                          module H :
                            sig
                              type key = WpModel.F.LTypeinfo.H.key
                              type 'a t = 'WpModel.F.LTypeinfo.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module Cobject :
                        sig
                          type t = Ctypes.c_object
                          module H :
                            sig
                              type key = WpModel.F.Cobject.H.key
                              type 'a t = 'WpModel.F.Cobject.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      module ArrayDim :
                        sig
                          type t = Ctypes.c_object * int
                          module H :
                            sig
                              type key = WpModel.F.ArrayDim.H.key
                              type 'a t = 'WpModel.F.ArrayDim.H.t
                              val create : int -> 'a t
                              val clear : 'a t -> unit
                              val copy : 'a t -> 'a t
                              val add : 'a t -> key -> '-> unit
                              val remove : 'a t -> key -> unit
                              val find : 'a t -> key -> 'a
                              val find_all : 'a t -> key -> 'a list
                              val replace : 'a t -> key -> '-> unit
                              val mem : 'a t -> key -> bool
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val length : 'a t -> int
                            end
                          val index : t -> H.key
                          val prefix : string
                          val basename : t -> string
                          val location : t -> Lexing.position option
                          val pp_title : Format.formatter -> t -> unit
                          val pp_descr : Format.formatter -> t -> unit
                        end
                      val adt_decl : Cil_types.logic_type_info -> string
                      val pp_tau : Format.formatter -> Formula.tau -> unit
                      val e_true : boolean
                      val e_false : boolean
                      val e_float : float -> real
                      val e_icst : string -> integer
                      val e_rcst : string -> real
                      val e_int64 : int64 -> integer
                      val e_ineg : integer -> integer
                      val e_rneg : real -> real
                      val e_iop :
                        Formula.int_op -> integer -> integer -> integer
                      val e_rop : Formula.real_op -> real -> real -> real
                      val e_icmp :
                        Formula.cmp_op -> integer -> integer -> boolean
                      val e_rcmp : Formula.cmp_op -> real -> real -> boolean
                      val p_icmp :
                        Formula.cmp_op -> integer -> integer -> pred
                      val p_rcmp : Formula.cmp_op -> real -> real -> pred
                      val e_bnot : integer -> integer
                      val e_band : integer -> integer -> integer
                      val e_bor : integer -> integer -> integer
                      val e_bxor : integer -> integer -> integer
                      val e_lshift : integer -> integer -> integer
                      val e_rshift : integer -> integer -> integer
                      val integer_of_real : real -> integer
                      val real_of_integer : integer -> real
                      val e_bool : boolean -> integer
                      val e_not : boolean -> boolean
                      val e_and : boolean -> boolean -> boolean
                      val e_or : boolean -> boolean -> boolean
                      val e_cond : boolean -> 'a term -> 'a term -> 'a term
                      val p_cond : boolean -> pred -> pred -> pred
                      val e_getfield :
                        Cil_types.fieldinfo -> record -> abstract
                      val e_setfield :
                        Cil_types.fieldinfo -> record -> abstract -> record
                      val e_access : array -> integer -> abstract
                      val e_update : array -> integer -> abstract -> array
                      val p_true : pred
                      val p_false : pred
                      val p_bool : boolean -> pred
                      val p_and : pred -> pred -> pred
                      val p_or : pred -> pred -> pred
                      val p_xor : pred -> pred -> pred
                      val p_not : pred -> pred
                      val p_implies : pred -> pred -> pred
                      val p_iff : pred -> pred -> pred
                      val p_eq : 'a term -> 'a term -> pred
                      val p_neq : 'a term -> 'a term -> pred
                      val p_conj : pred list -> pred
                      val p_disj : pred list -> pred
                      val p_named : string -> pred -> pred
                      val is_true : pred -> bool
                      val is_false : pred -> bool
                      val huge_term : int -> 'a term -> bool
                      val huge_pred : int -> pred -> bool
                      type pool = WpModel.F.pool
                      val pool : unit -> pool
                      val p_fresh : pool -> string -> Formula.kind -> var
                      val p_freshen : pool -> var -> var
                      val var : var -> 'a term
                      val eq_var : var -> var -> bool
                      val name_of_var : var -> string
                      val basename_of_var : var -> string
                      val tau_of_var : var -> Formula.tau
                      val kind_of_var : var -> Formula.kind
                      val term_has_var : var list -> 'a term -> bool
                      val pred_has_var : var list -> pred -> bool
                      val term_calls : string -> 'a term -> bool
                      val pred_calls : string -> pred -> bool
                      val term_closed : 'a term -> bool
                      val pred_closed : pred -> bool
                      val freevars : pred -> var list
                      val p_forall : var list -> pred -> pred
                      val p_exists : var list -> pred -> pred
                      val p_subst :
                        (var -> var option) -> var -> 'a term -> pred -> pred
                      val e_subst :
                        (var -> var option) ->
                        var -> 'a term -> 'b term -> 'b term
                      val e_rename : (var * var) list -> 'a term -> 'a term
                      val equal_terms : 'a term -> 'a term -> bool
                      type alpha = WpModel.F.alpha
                      val empty_alpha : alpha
                      val fold_alpha :
                        (var -> var -> '-> 'a) -> alpha -> '-> 'a
                      val p_more_alpha_cv : alpha -> pred -> alpha * pred
                      val p_alpha_cv : pred -> var list * pred
                      val pp_var : Format.formatter -> var -> unit
                      val pp_section : Format.formatter -> string -> unit
                      val pp_term : Format.formatter -> 'a term -> unit
                      val pp_pred : Format.formatter -> pred -> unit
                      val pp_decl : Format.formatter -> decl -> unit
                      val pp_goal :
                        Format.formatter -> string -> pred -> unit
                      val pp_vkind : Format.formatter -> Formula.kind -> unit
                      val e_app0 : string -> 'a term
                      val e_app1 : string -> 'a term -> 'b term
                      val e_app2 : string -> 'a term -> 'b term -> 'c term
                      val e_app3 :
                        string -> 'a term -> 'b term -> 'c term -> 'd term
                      val e_app4 :
                        string ->
                        'a term -> 'b term -> 'c term -> 'd term -> 'e term
                      val e_app5 :
                        string ->
                        'a term ->
                        'b term -> 'c term -> 'd term -> 'e term -> 'f term
                      val p_app0 : string -> pred
                      val p_app1 : string -> 'a term -> pred
                      val p_app2 : string -> 'a term -> 'b term -> pred
                      val p_app3 :
                        string -> 'a term -> 'b term -> 'c term -> pred
                      val p_app4 :
                        string ->
                        'a term -> 'b term -> 'c term -> 'd term -> pred
                      val p_app5 :
                        string ->
                        'a term ->
                        'b term -> 'c term -> 'd term -> 'e term -> pred
                      val dummy : unit -> pred
                      val i_zero : integer
                      val r_zero : real
                      val i_one : integer
                      val i_add : integer -> integer -> integer
                      val i_mult : integer -> integer -> integer
                      val i_sub : integer -> integer -> integer
                      val guard : Ctypes.c_int -> integer -> pred
                      val modulo : Ctypes.c_int -> integer -> integer
                      val i_convert :
                        Ctypes.c_int -> Ctypes.c_int -> integer -> integer
                      type interval =
                        WpModel.F.interval = {
                        inf : integer option;
                        sup : integer option;
                      }
                      type 'a assigned =
                        'WpModel.F.assigned =
                          Aloc of Ctypes.c_object * 'a
                        | Arange of Ctypes.c_object * 'a * interval
                      type havoc =
                        WpModel.F.havoc =
                          Fresh of var
                        | Update of var * ((var * var) list -> abstract)
                      val pp_interval : Format.formatter -> interval -> unit
                      val set_range_index : array -> interval -> array
                      val empty : set
                      val singleton : abstract -> set
                      val union : set -> set -> set
                      val unions : set list -> set
                      val inter : set -> set -> set
                      val remove : set -> set -> set
                      val set_of_list : abstract list -> set
                      val add_set : set -> set -> set
                      val mult_set : set -> set -> set
                      val neg_set : set -> set
                      val interval : interval -> set
                      val acc_field :
                        record -> Cil_types.fieldinfo -> abstract
                      val upd_field :
                        record -> Cil_types.fieldinfo -> abstract -> record
                      val acc_index : array -> integer -> abstract
                      val upd_index : array -> integer -> abstract -> array
                      module type Indexed =
                        sig
                          type t
                          val define : t -> unit
                          val get_definition : t -> decl
                          val on_definition : (t -> decl -> unit) -> unit
                          val get_ind : t -> integer
                          val has_ind : t -> pred -> bool
                        end
                      module Dindex :
                        functor (I : Identifiable->
                          sig
                            type t = I.t
                            val define : t -> unit
                            val get_definition : t -> decl
                            val on_definition : (t -> decl -> unit) -> unit
                            val get_ind : t -> integer
                            val has_ind : t -> pred -> bool
                          end
                      module Findex :
                        sig
                          type t = Cil_types.fieldinfo
                          val define : t -> unit
                          val get_definition : t -> decl
                          val on_definition : (t -> decl -> unit) -> unit
                          val get_ind : t -> integer
                          val has_ind : t -> pred -> bool
                        end
                      module Xindex :
                        sig
                          type t = Cil_types.varinfo
                          val define : t -> unit
                          val get_definition : t -> decl
                          val on_definition : (t -> decl -> unit) -> unit
                          val get_ind : t -> integer
                          val has_ind : t -> pred -> bool
                        end
                      module Aindex :
                        sig
                          type t = Cil_types.varinfo
                          val define : t -> unit
                          val get_definition : t -> decl
                          val on_definition : (t -> decl -> unit) -> unit
                          val get_ind : t -> integer
                          val has_ind : t -> pred -> bool
                        end
                      module Tindex :
                        sig
                          type t = Cil_types.compinfo
                          val define : t -> unit
                          val get_definition : t -> decl
                          val on_definition : (t -> decl -> unit) -> unit
                          val get_ind : t -> integer
                          val has_ind : t -> pred -> bool
                        end
                      module LTindex :
                        sig
                          type t = Cil_types.logic_type
                          val define : t -> unit
                          val get_definition : t -> decl
                          val on_definition : (t -> decl -> unit) -> unit
                          val get_ind : t -> integer
                          val has_ind : t -> pred -> bool
                        end
                    end
                  type context = WpModel.L.context
                  type bindings = WpModel.L.bindings
                  val closed : bindings
                  val close : bindings -> F.pred -> F.pred
                  val push : string -> F.pool -> bindings -> context
                  val pop : string -> context -> bindings
                  val kill : string -> context -> unit
                  val flush : string -> context -> F.pred -> F.pred
                  val term_such_that :
                    Formula.tau -> ('F.term -> F.pred) -> 'F.term
                  val forall : F.var list -> F.pred -> F.pred
                  val exists : F.var list -> F.pred -> F.pred
                  val subst : F.var -> 'F.term -> F.pred -> F.pred
                  val fresh : string -> Formula.kind -> F.var
                  val alpha : F.var -> F.var option
                  val pool : unit -> F.pool
                  val vkind_of_var : F.var -> Formula.kind
                  val has_context_vars : F.var list -> F.pred -> bool
                  val has_type : F.abstract -> Cil_types.logic_type -> F.pred
                  val is_comp : Cil_types.compinfo -> F.abstract -> F.pred
                  val is_array : Ctypes.arrayinfo -> F.abstract -> F.pred
                  val apply : (F.var * F.var) list -> 'F.term -> 'F.term
                  val havoc_static : F.havoc list -> F.pred -> F.pred
                  val havoc_inductive : F.havoc list -> F.pred -> F.pred
                end
              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 :
                    ?lvars:Cil_types.logic_var list ->
                    Cil_types.kernel_function -> t_env
                  val add_axiom :
                    WpPropId.prop_id ->
                    string ->
                    Cil_types.logic_label list ->
                    Cil_types.predicate Cil_types.named -> unit
                  val add_hyp :
                    t_env -> WpPropId.pred_info -> t_prop -> t_prop
                  val add_goal :
                    t_env -> WpPropId.pred_info -> t_prop -> t_prop
                  val add_assigns :
                    t_env -> WpPropId.assigns_info -> t_prop -> t_prop
                  val use_assigns :
                    t_env ->
                    WpPropId.prop_id option ->
                    WpPropId.assigns_desc -> t_prop -> t_prop
                  val assigns_method : unit -> Mcfg.assigns_method
                  val label : t_env -> Clabels.c_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 init_value :
                    t_env ->
                    Cil_types.lval ->
                    Cil_types.typ -> Cil_types.exp option -> t_prop -> t_prop
                  val init_range :
                    t_env ->
                    Cil_types.lval ->
                    Cil_types.typ -> int64 -> int64 -> t_prop -> t_prop
                  val tag : string -> t_prop -> t_prop
                  val call_goal_precond :
                    t_env ->
                    Cil_types.stmt ->
                    Cil_types.kernel_function ->
                    Cil_types.exp list ->
                    pre:WpPropId.pred_info list -> t_prop -> t_prop
                  val call :
                    t_env ->
                    Cil_types.stmt ->
                    Cil_types.lval option ->
                    Cil_types.kernel_function ->
                    Cil_types.exp list ->
                    pre:WpPropId.pred_info list ->
                    post:WpPropId.pred_info list ->
                    pexit:WpPropId.pred_info list ->
                    assigns:Cil_types.identified_term Cil_types.assigns ->
                    p_post:t_prop -> p_exit: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 -> WpPropId.pred_info list -> t_prop -> t_prop
                  val close : t_env -> t_prop -> t_prop
                  val zip : t_prop -> WpModel.F.pred
                end
              module PO :
                sig
                  type description = Cfgpropid.Create(CV).description
                  type t_goal =
                    Cfgpropid.Create(CV).t_goal = {
                    g_id : WpPropId.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) ->
                    (Property.t -> 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 :
                    ?lvars:Cil_types.logic_var list ->
                    Cil_types.kernel_function -> t_env
                  val add_axiom :
                    WpPropId.prop_id ->
                    string ->
                    Cil_types.logic_label list ->
                    Cil_types.predicate Cil_types.named -> unit
                  val add_hyp :
                    t_env -> WpPropId.pred_info -> t_prop -> t_prop
                  val add_goal :
                    t_env -> WpPropId.pred_info -> t_prop -> t_prop
                  val add_assigns :
                    t_env -> WpPropId.assigns_info -> t_prop -> t_prop
                  val use_assigns :
                    t_env ->
                    WpPropId.prop_id option ->
                    WpPropId.assigns_desc -> t_prop -> t_prop
                  val assigns_method : unit -> Mcfg.assigns_method
                  val label : t_env -> Clabels.c_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 init_value :
                    t_env ->
                    Cil_types.lval ->
                    Cil_types.typ -> Cil_types.exp option -> t_prop -> t_prop
                  val init_range :
                    t_env ->
                    Cil_types.lval ->
                    Cil_types.typ -> int64 -> int64 -> t_prop -> t_prop
                  val tag : string -> t_prop -> t_prop
                  val call_goal_precond :
                    t_env ->
                    Cil_types.stmt ->
                    Cil_types.kernel_function ->
                    Cil_types.exp list ->
                    pre:WpPropId.pred_info list -> t_prop -> t_prop
                  val call :
                    t_env ->
                    Cil_types.stmt ->
                    Cil_types.lval option ->
                    Cil_types.kernel_function ->
                    Cil_types.exp list ->
                    pre:WpPropId.pred_info list ->
                    post:WpPropId.pred_info list ->
                    pexit:WpPropId.pred_info list ->
                    assigns:Cil_types.identified_term Cil_types.assigns ->
                    p_post:t_prop -> p_exit: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 -> WpPropId.pred_info list -> t_prop -> t_prop
                  val close : t_env -> t_prop -> t_prop
                end
              module WP :
                sig
                  val compute :
                    Cil2cfg.t ->
                    WpStrategy.strategy ->
                    PO.t_prop list *
                    (Format.formatter -> Cil2cfg.edge -> unit)
                end
              type exportation = {
                env : string;
                mutable goals : Wpo.t list;
              }
              val assigns_method : unit -> Mcfg.assigns_method
              val active_lgg : unit -> Wpo.language option
              val export_wpo :
                CfgProof.Create.exportation ->
                Kernel_function.t ->
                string option ->
                Wpo.warning list ->
                Property.t list ->
                WpPropId.prop_id -> CfgProof.Create.F.pred -> unit
              val build_wpos :
                CfgProof.Create.exportation ->
                Kernel_function.t ->
                string option ->
                Wpo.warning list ->
                Property.t list -> WpPropId.prop_id -> Splitter.pred -> unit
              val add_goal :
                CfgProof.Create.exportation ->
                Kernel_function.t ->
                string option -> CfgProof.Create.PO.t_goal -> unit
              class computer :
                object
                  val mutable exported : 'a option
                  val mutable wptasks : WpStrategy.strategy list list
                  method add : WpStrategy.strategy list -> unit
                  method compute : Wpo.t list
                end
              val create : unit -> CfgProof.Create.computer
            end