sig
  module Wp_parameters :
    sig
      type category
      type warn_category
      val verbose_atleast : int -> bool
      val debug_atleast : int -> bool
      val printf :
        ?level:int ->
        ?dkey:category ->
        ?current:bool ->
        ?source:Filepath.position ->
        ?append:(Format.formatter -> unit) ->
        ?header:(Format.formatter -> unit) ->
        ('a, Format.formatter, unit) format -> 'a
      val result : ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val feedback :
        ?ontty:Log.ontty ->
        ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val debug : ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val warning : ?wkey:warn_category -> 'Log.pretty_printer
      val error : 'Log.pretty_printer
      val abort : ('a, 'b) Log.pretty_aborter
      val failure : 'Log.pretty_printer
      val fatal : ('a, 'b) Log.pretty_aborter
      val verify : bool -> ('a, bool) Log.pretty_aborter
      val not_yet_implemented :
        ?current:bool ->
        ?source:Filepath.position ->
        ('a, Format.formatter, unit, 'b) format4 -> 'a
      val deprecated : string -> now:string -> ('-> 'b) -> '-> 'b
      val with_result :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_warning :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_error :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_failure :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val log :
        ?kind:Log.kind -> ?verbose:int -> ?debug:int -> 'Log.pretty_printer
      val logwith :
        (Log.event option -> 'b) ->
        ?wkey:warn_category ->
        ?emitwith:(Log.event -> unit) ->
        ?once:bool -> ('a, 'b) Log.pretty_aborter
      val register : Log.kind -> (Log.event -> unit) -> unit
      val register_tag_handlers :
        (string -> string) * (string -> string) -> unit
      val register_category : string -> category
      val pp_category : Format.formatter -> category -> unit
      val dkey_name : category -> string
      val is_registered_category : string -> bool
      val get_category : string -> category option
      val get_all_categories : unit -> category list
      val add_debug_keys : category -> unit
      val del_debug_keys : category -> unit
      val get_debug_keys : unit -> category list
      val is_debug_key_enabled : category -> bool
      val get_debug_keyset : unit -> category list
      val register_warn_category : string -> warn_category
      val is_warn_category : string -> bool
      val pp_warn_category : Format.formatter -> warn_category -> unit
      val pp_all_warn_categories_status : unit -> unit
      val wkey_name : warn_category -> string
      val get_warn_category : string -> warn_category option
      val get_all_warn_categories : unit -> warn_category list
      val get_all_warn_categories_status :
        unit -> (warn_category * Log.warn_status) list
      val set_warn_status : warn_category -> Log.warn_status -> unit
      val get_warn_status : warn_category -> Log.warn_status
      val add_group : ?memo:bool -> string -> Cmdline.Group.t
      module Help : Parameter_sig.Bool
      module Verbose : Parameter_sig.Int
      module Debug : Parameter_sig.Int
      module Share : Parameter_sig.Specific_dir
      module Session : Parameter_sig.Specific_dir
      module Config : Parameter_sig.Specific_dir
      val help : Cmdline.Group.t
      val messages : Cmdline.Group.t
      val add_plugin_output_aliases :
        ?visible:bool -> ?deprecated:bool -> string list -> unit
      val reset : unit -> unit
      val hypothesis : 'Log.pretty_printer
      type functions =
          Fct_none
        | Fct_all
        | Fct_skip of Cil_datatype.Kf.Set.t
        | Fct_list of Cil_datatype.Kf.Set.t
      val get_fct : unit -> Wp.Wp_parameters.functions
      val iter_fct :
        (Kernel_function.t -> unit) -> Wp.Wp_parameters.functions -> unit
      val iter_kf : (Kernel_function.t -> unit) -> unit
      module WP : Parameter_sig.Bool
      module Dump : Parameter_sig.Bool
      module Behaviors : Parameter_sig.String_list
      module Properties : Parameter_sig.String_list
      module StatusAll : Parameter_sig.Bool
      module StatusTrue : Parameter_sig.Bool
      module StatusFalse : Parameter_sig.Bool
      module StatusMaybe : Parameter_sig.Bool
      val has_dkey : category -> bool
      module Model : Parameter_sig.String_list
      module ByValue : Parameter_sig.String_set
      module ByRef : Parameter_sig.String_set
      module InHeap : Parameter_sig.String_set
      module AliasInit : Parameter_sig.Bool
      module InCtxt : Parameter_sig.String_set
      module ExternArrays : Parameter_sig.Bool
      module Literals : Parameter_sig.Bool
      module Volatile : Parameter_sig.Bool
      module WeakIntModel : Parameter_sig.Bool
      module Region : Parameter_sig.Bool
      module Region_rw : Parameter_sig.Bool
      module Region_pack : Parameter_sig.Bool
      module Region_flat : Parameter_sig.Bool
      module Region_annot : Parameter_sig.Bool
      module Region_inline : Parameter_sig.Bool
      module Region_fixpoint : Parameter_sig.Bool
      module Region_cluster : Parameter_sig.Bool
      module Region_output_dot : Parameter_sig.Filepath
      module Init : Parameter_sig.Bool
      module InitWithForall : Parameter_sig.Bool
      module BoundForallUnfolding : Parameter_sig.Int
      module RTE : Parameter_sig.Bool
      module Simpl : Parameter_sig.Bool
      module Let : Parameter_sig.Bool
      module Core : Parameter_sig.Bool
      module Prune : Parameter_sig.Bool
      module FilterInit : Parameter_sig.Bool
      module Clean : Parameter_sig.Bool
      module Filter : Parameter_sig.Bool
      module Parasite : Parameter_sig.Bool
      module Prenex : Parameter_sig.Bool
      module Ground : Parameter_sig.Bool
      module Reduce : Parameter_sig.Bool
      module ExtEqual : Parameter_sig.Bool
      module UnfoldAssigns : Parameter_sig.Int
      module Split : Parameter_sig.Bool
      module SplitMax : Parameter_sig.Int
      module SplitDepth : Parameter_sig.Int
      module DynCall : Parameter_sig.Bool
      module SimplifyIsCint : Parameter_sig.Bool
      module SimplifyLandMask : Parameter_sig.Bool
      module SimplifyForall : Parameter_sig.Bool
      module SimplifyType : Parameter_sig.Bool
      module CalleePreCond : Parameter_sig.Bool
      module PrecondWeakening : Parameter_sig.Bool
      module TerminatesExtDeclarations : Parameter_sig.Bool
      module TerminatesStdlibDeclarations : Parameter_sig.Bool
      module TerminatesDefinitions : Parameter_sig.Bool
      module TerminatesVariantHyp : Parameter_sig.Bool
      module Detect : Parameter_sig.Bool
      module Generate : Parameter_sig.Bool
      module ScriptOnStdout : Parameter_sig.Bool
      module Provers : Parameter_sig.String_list
      module Interactive : Parameter_sig.String
      module RunAllProvers : Parameter_sig.Bool
      module Cache : Parameter_sig.String
      module CacheEnv : Parameter_sig.Bool
      module CacheDir : Parameter_sig.String
      module CachePrint : Parameter_sig.Bool
      module Drivers : Parameter_sig.String_list
      module Timeout : Parameter_sig.Int
      module FctTimeout :
        sig
          type key = Cil_types.kernel_function
          type value = int
          type t
          val set : t -> unit
          val add_set_hook : (t -> t -> unit) -> unit
          val add_update_hook : (t -> t -> unit) -> unit
          val get : unit -> t
          val clear : unit -> unit
          val is_default : unit -> bool
          val get_default : unit -> t
          val option_name : string
          val print_help : Format.formatter -> unit
          val self : State.t
          val name : string
          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
          val equal : t -> t -> bool
          val add_aliases :
            ?visible:bool -> ?deprecated:bool -> string list -> unit
          val is_set : unit -> bool
          val unsafe_set : t -> unit
          val parameter : Typed_parameter.t
          type elt = key * value option
          val is_empty : unit -> bool
          val iter : (elt -> unit) -> unit
          val fold : (elt -> '-> 'a) -> '-> 'a
          val add : elt -> unit
          module As_string : Parameter_sig.String
          module Category :
            sig
              type elt = elt
              type t = elt Parameter_category.t
              val none : t
              val default : unit -> t
              val all : unit -> t
              val set_default : t -> unit
              val add :
                string ->
                State.t list -> elt Parameter_category.accessor -> t
              val enable_all :
                State.t list -> elt Parameter_category.accessor -> t
              val enable_all_as : t -> unit
            end
          val find : key -> value
          val mem : key -> bool
        end
      module SmokeTimeout : Parameter_sig.Int
      module InteractiveTimeout : Parameter_sig.Int
      module TimeExtra : Parameter_sig.Int
      module TimeMargin : Parameter_sig.Int
      module Steps : Parameter_sig.Int
      module Procs : Parameter_sig.Int
      module ProofTrace : Parameter_sig.Bool
      module Why3Flags : Parameter_sig.String_list
      module Auto : Parameter_sig.String_list
      module AutoDepth : Parameter_sig.Int
      module AutoWidth : Parameter_sig.Int
      module BackTrack : Parameter_sig.Int
      module TruncPropIdFileName : Parameter_sig.Int
      module Print : Parameter_sig.Bool
      module Report : Parameter_sig.String_list
      module ReportJson : Parameter_sig.String
      module ReportName : Parameter_sig.String
      module MemoryContext : Parameter_sig.Bool
      module CheckMemoryContext : Parameter_sig.Bool
      module SmokeTests : Parameter_sig.Bool
      module SmokeDeadassumes : Parameter_sig.Bool
      module SmokeDeadcode : Parameter_sig.Bool
      module SmokeDeadcall : Parameter_sig.Bool
      module SmokeDeadlocalinit : Parameter_sig.Bool
      module SmokeDeadloop : Parameter_sig.Bool
      val has_out : unit -> bool
      val has_session : unit -> bool
      val get_session : force:bool -> unit -> Datatype.Filepath.t
      val get_session_dir : force:bool -> string -> Datatype.Filepath.t
      val get_output : unit -> Datatype.Filepath.t
      val get_output_dir : string -> Datatype.Filepath.t
      val make_output_dir : string -> unit
      val has_print_generated : unit -> bool
      val print_generated : ?header:string -> string -> unit
      val cat_print_generated : category
      val protect : exn -> bool
    end
  module Ctypes :
    sig
      type c_int =
          CBool
        | UInt8
        | SInt8
        | UInt16
        | SInt16
        | UInt32
        | SInt32
        | UInt64
        | SInt64
      type c_float = Float32 | Float64
      type arrayflat = {
        arr_size : int;
        arr_dim : int;
        arr_cell : Cil_types.typ;
        arr_cell_nbr : int64;
      }
      type arrayinfo = {
        arr_element : Cil_types.typ;
        arr_flat : Wp.Ctypes.arrayflat option;
      }
      type c_object =
          C_int of Wp.Ctypes.c_int
        | C_float of Wp.Ctypes.c_float
        | C_pointer of Cil_types.typ
        | C_comp of Cil_types.compinfo
        | C_array of Wp.Ctypes.arrayinfo
      val object_of_pointed : Wp.Ctypes.c_object -> Wp.Ctypes.c_object
      val object_of_array_elem : Wp.Ctypes.c_object -> Wp.Ctypes.c_object
      val object_of_logic_type : Cil_types.logic_type -> Wp.Ctypes.c_object
      val object_of_logic_pointed :
        Cil_types.logic_type -> Wp.Ctypes.c_object
      val i_iter : (Wp.Ctypes.c_int -> unit) -> unit
      val f_iter : (Wp.Ctypes.c_float -> unit) -> unit
      val i_memo : (Wp.Ctypes.c_int -> 'a) -> Wp.Ctypes.c_int -> 'a
      val f_memo : (Wp.Ctypes.c_float -> 'a) -> Wp.Ctypes.c_float -> 'a
      val is_char : Wp.Ctypes.c_int -> bool
      val c_char : unit -> Wp.Ctypes.c_int
      val c_bool : unit -> Wp.Ctypes.c_int
      val c_ptr : unit -> Wp.Ctypes.c_int
      val c_int : Cil_types.ikind -> Wp.Ctypes.c_int
      val c_float : Cil_types.fkind -> Wp.Ctypes.c_float
      val object_of : Cil_types.typ -> Wp.Ctypes.c_object
      val is_pointer : Wp.Ctypes.c_object -> bool
      val char : char -> int64
      val constant : Cil_types.exp -> int64
      val get_int : Cil_types.exp -> int option
      val get_int64 : Cil_types.exp -> int64 option
      val signed : Wp.Ctypes.c_int -> bool
      val bounds : Wp.Ctypes.c_int -> Integer.t * Integer.t
      val i_bits : Wp.Ctypes.c_int -> int
      val i_bytes : Wp.Ctypes.c_int -> int
      val f_bits : Wp.Ctypes.c_float -> int
      val f_bytes : Wp.Ctypes.c_float -> int
      val p_bits : unit -> int
      val p_bytes : unit -> int
      val sub_c_int : Wp.Ctypes.c_int -> Wp.Ctypes.c_int -> bool
      val equal_float : Wp.Ctypes.c_float -> Wp.Ctypes.c_float -> bool
      val sizeof_defined : Wp.Ctypes.c_object -> bool
      val sizeof_object : Wp.Ctypes.c_object -> int
      val bits_sizeof_comp : Cil_types.compinfo -> int
      val bits_sizeof_array : Wp.Ctypes.arrayinfo -> int
      val bits_sizeof_object : Wp.Ctypes.c_object -> int
      val field_offset : Cil_types.fieldinfo -> int
      val no_infinite_array : Wp.Ctypes.c_object -> bool
      val is_compound : Wp.Ctypes.c_object -> bool
      val is_comp : Wp.Ctypes.c_object -> Cil_types.compinfo -> bool
      val is_array : Wp.Ctypes.c_object -> elt:Wp.Ctypes.c_object -> bool
      val get_array :
        Wp.Ctypes.c_object -> (Wp.Ctypes.c_object * int option) option
      val get_array_size : Wp.Ctypes.c_object -> int option
      val get_array_dim : Wp.Ctypes.c_object -> int
      val array_size : Wp.Ctypes.arrayinfo -> int option
      val array_dimensions :
        Wp.Ctypes.arrayinfo -> Wp.Ctypes.c_object * int option list
      val dimension_of_object : Wp.Ctypes.c_object -> (int * int64) option
      val i_convert : Wp.Ctypes.c_int -> Wp.Ctypes.c_int -> Wp.Ctypes.c_int
      val f_convert :
        Wp.Ctypes.c_float -> Wp.Ctypes.c_float -> Wp.Ctypes.c_float
      val promote :
        Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> Wp.Ctypes.c_object
      val pp_int : Stdlib.Format.formatter -> Wp.Ctypes.c_int -> unit
      val pp_float : Stdlib.Format.formatter -> Wp.Ctypes.c_float -> unit
      val pp_object : Stdlib.Format.formatter -> Wp.Ctypes.c_object -> unit
      val i_name : Wp.Ctypes.c_int -> string
      val f_name : Wp.Ctypes.c_float -> string
      val basename : Wp.Ctypes.c_object -> string
      val compare : Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> int
      val equal : Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> bool
      val hash : Wp.Ctypes.c_object -> int
      val pretty : Stdlib.Format.formatter -> Wp.Ctypes.c_object -> unit
      module C_object :
        sig
          type t = c_object
          val ty : t Type.t
          val name : string
          val descr : t Descr.t
          val packed_descr : Structural_descr.pack
          val reprs : t list
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val hash : t -> int
          val pretty_code : Format.formatter -> t -> unit
          val internal_pretty_code :
            Type.precedence -> Format.formatter -> t -> unit
          val pretty : Format.formatter -> t -> unit
          val varname : t -> string
          val mem_project : (Project_skeleton.t -> bool) -> t -> bool
          val copy : t -> t
        end
      module AinfoComparable :
        sig
          type t = Wp.Ctypes.arrayinfo
          val compare :
            Wp.Ctypes.AinfoComparable.t -> Wp.Ctypes.AinfoComparable.t -> int
          val equal :
            Wp.Ctypes.AinfoComparable.t ->
            Wp.Ctypes.AinfoComparable.t -> bool
          val hash : Wp.Ctypes.AinfoComparable.t -> int
        end
      val compare_c_int : Wp.Ctypes.c_int -> Wp.Ctypes.c_int -> int
      val compare_c_float : Wp.Ctypes.c_float -> Wp.Ctypes.c_float -> int
      val compare_ptr_conflated :
        Wp.Ctypes.c_object -> Wp.Ctypes.c_object -> int
    end
  module Clabels :
    sig
      type c_label
      val is_here : Wp.Clabels.c_label -> bool
      val mem : Wp.Clabels.c_label -> Wp.Clabels.c_label list -> bool
      val equal : Wp.Clabels.c_label -> Wp.Clabels.c_label -> bool
      module T :
        sig
          type t = Wp.Clabels.c_label
          val compare : Wp.Clabels.T.t -> Wp.Clabels.T.t -> int
        end
      module LabelMap :
        sig
          type key = c_label
          type +!'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
      module LabelSet :
        sig
          type elt = c_label
          type t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val disjoint : t -> t -> bool
          val diff : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val map : (elt -> elt) -> t -> t
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val filter_map : (elt -> elt option) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_list : elt list -> t
          val to_seq_from : elt -> t -> elt Seq.t
          val to_seq : t -> elt Seq.t
          val to_rev_seq : t -> elt Seq.t
          val add_seq : elt Seq.t -> t -> t
          val of_seq : elt Seq.t -> t
        end
      val pre : Wp.Clabels.c_label
      val here : Wp.Clabels.c_label
      val next : Wp.Clabels.c_label
      val init : Wp.Clabels.c_label
      val post : Wp.Clabels.c_label
      val exit : Wp.Clabels.c_label
      val break : Wp.Clabels.c_label
      val continue : Wp.Clabels.c_label
      val default : Wp.Clabels.c_label
      val loopentry : Wp.Clabels.c_label
      val loopcurrent : Wp.Clabels.c_label
      val formal : string -> Wp.Clabels.c_label
      val case : int64 -> Wp.Clabels.c_label
      val stmt : Cil_types.stmt -> Wp.Clabels.c_label
      val stmt_post : Cil_types.stmt -> Wp.Clabels.c_label
      val loop_entry : Cil_types.stmt -> Wp.Clabels.c_label
      val loop_current : Cil_types.stmt -> Wp.Clabels.c_label
      val to_logic : Wp.Clabels.c_label -> Cil_types.logic_label
      val of_logic : Cil_types.logic_label -> Wp.Clabels.c_label
      val is_post : Cil_types.logic_label -> bool
      val pretty : Stdlib.Format.formatter -> Wp.Clabels.c_label -> unit
      val name : Cil_types.logic_label -> string
      val lookup :
        (Cil_types.logic_label * Cil_types.logic_label) list ->
        string -> Cil_types.logic_label
    end
  module MemoryContext :
    sig
      type validity = Valid | Nullable
      type param =
          NotUsed
        | ByAddr
        | ByValue
        | ByShift
        | ByRef
        | InContext of Wp.MemoryContext.validity
        | InArray of Wp.MemoryContext.validity
      val pp_param :
        Stdlib.Format.formatter -> Wp.MemoryContext.param -> unit
      type partition
      val empty : Wp.MemoryContext.partition
      val set :
        Cil_types.varinfo ->
        Wp.MemoryContext.param ->
        Wp.MemoryContext.partition -> Wp.MemoryContext.partition
      val compute :
        string ->
        (Cil_types.kernel_function -> Wp.MemoryContext.partition) -> unit
      val add_behavior :
        Cil_types.kernel_function ->
        string ->
        (Cil_types.kernel_function -> Wp.MemoryContext.partition) -> unit
      val warn :
        Cil_types.kernel_function ->
        string ->
        (Cil_types.kernel_function -> Wp.MemoryContext.partition) -> unit
    end
  module LogicUsage :
    sig
      val basename : Cil_types.varinfo -> string
      type logic_lemma = {
        lem_name : string;
        lem_position : Filepath.position;
        lem_types : string list;
        lem_labels : Cil_types.logic_label list;
        lem_predicate : Cil_types.toplevel_predicate;
        lem_depends : Wp.LogicUsage.logic_lemma list;
        lem_attrs : Cil_types.attributes;
      }
      type axiomatic = {
        ax_name : string;
        ax_position : Filepath.position;
        ax_property : Property.t;
        mutable ax_types : Cil_types.logic_type_info list;
        mutable ax_logics : Cil_types.logic_info list;
        mutable ax_lemmas : Wp.LogicUsage.logic_lemma list;
        mutable ax_reads : Cil_datatype.Varinfo.Set.t;
      }
      type logic_section =
          Toplevel of int
        | Axiomatic of Wp.LogicUsage.axiomatic
      val compute : unit -> unit
      val ip_lemma : Wp.LogicUsage.logic_lemma -> Property.t
      val iter_lemmas : (Wp.LogicUsage.logic_lemma -> unit) -> unit
      val fold_lemmas : (Wp.LogicUsage.logic_lemma -> '-> 'a) -> '-> 'a
      val logic_lemma : string -> Wp.LogicUsage.logic_lemma
      val axiomatic : string -> Wp.LogicUsage.axiomatic
      val section_of_lemma : string -> Wp.LogicUsage.logic_section
      val section_of_type :
        Cil_types.logic_type_info -> Wp.LogicUsage.logic_section
      val section_of_logic :
        Cil_types.logic_info -> Wp.LogicUsage.logic_section
      val proof_context : unit -> Wp.LogicUsage.logic_lemma list
      val is_recursive : Cil_types.logic_info -> bool
      val get_induction_labels :
        Cil_types.logic_info ->
        string -> Wp.Clabels.LabelSet.t Wp.Clabels.LabelMap.t
      val get_name : Cil_types.logic_info -> string
      val pp_profile :
        Stdlib.Format.formatter -> Cil_types.logic_info -> unit
      val dump : unit -> unit
    end
  module RefUsage :
    sig
      type access = NoAccess | ByRef | ByArray | ByValue | ByAddr
      val get :
        ?kf:Cil_types.kernel_function ->
        ?init:bool -> Cil_types.varinfo -> Wp.RefUsage.access
      val iter :
        ?kf:Cil_types.kernel_function ->
        ?init:bool ->
        (Cil_types.varinfo -> Wp.RefUsage.access -> unit) -> unit
      val is_nullable : Cil_types.varinfo -> bool
      val has_nullable : unit -> bool
      val print :
        Cil_types.varinfo ->
        Wp.RefUsage.access -> Stdlib.Format.formatter -> unit
      val dump : unit -> unit
      val compute : unit -> unit
      val is_computed : unit -> bool
    end
  module NormAtLabels :
    sig
      val catch_label_error : exn -> string -> string -> unit
      type label_mapping
      val labels_empty : Wp.NormAtLabels.label_mapping
      val labels_fct_pre : Wp.NormAtLabels.label_mapping
      val labels_fct_post : exit:bool -> Wp.NormAtLabels.label_mapping
      val labels_fct_assigns : exit:bool -> Wp.NormAtLabels.label_mapping
      val labels_assert :
        kf:Cil_types.kernel_function ->
        Cil_types.stmt -> Wp.NormAtLabels.label_mapping
      val labels_loop : Cil_types.stmt -> Wp.NormAtLabels.label_mapping
      val labels_stmt_pre :
        kf:Cil_types.kernel_function ->
        Cil_types.stmt -> Wp.NormAtLabels.label_mapping
      val labels_stmt_post :
        kf:Cil_types.kernel_function ->
        Cil_types.stmt -> Wp.NormAtLabels.label_mapping
      val labels_stmt_assigns :
        kf:Cil_types.kernel_function ->
        Cil_types.stmt -> Wp.NormAtLabels.label_mapping
      val labels_stmt_post_l :
        kf:Cil_types.kernel_function ->
        Cil_types.stmt ->
        Wp.Clabels.c_label option -> Wp.NormAtLabels.label_mapping
      val labels_stmt_assigns_l :
        kf:Cil_types.kernel_function ->
        Cil_types.stmt ->
        Wp.Clabels.c_label option -> Wp.NormAtLabels.label_mapping
      val labels_predicate :
        (Cil_types.logic_label * Cil_types.logic_label) list ->
        Wp.NormAtLabels.label_mapping
      val labels_axiom : Wp.NormAtLabels.label_mapping
      val preproc_term :
        Wp.NormAtLabels.label_mapping -> Cil_types.term -> Cil_types.term
      val preproc_annot :
        Wp.NormAtLabels.label_mapping ->
        Cil_types.predicate -> Cil_types.predicate
      val preproc_assigns :
        Wp.NormAtLabels.label_mapping ->
        Cil_types.from list -> Cil_types.from list
      val has_postassigns : Cil_types.assigns -> bool
    end
  module WpPropId :
    sig
      type prop_id
      val property_of_id : Wp.WpPropId.prop_id -> Property.t
      val doomed_if_valid : Wp.WpPropId.prop_id -> Property.t list
      val unreachable_if_valid : Wp.WpPropId.prop_id -> Property.other_loc
      val source_of_id : Wp.WpPropId.prop_id -> Filepath.position
      module PropId :
        sig
          type t = prop_id
          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 compare_prop_id : Wp.WpPropId.prop_id -> Wp.WpPropId.prop_id -> int
      val tactical : gid:string -> Wp.WpPropId.prop_id
      val is_check : Wp.WpPropId.prop_id -> bool
      val is_tactic : Wp.WpPropId.prop_id -> bool
      val is_assigns : Wp.WpPropId.prop_id -> bool
      val is_requires : Property.t -> bool
      val is_loop_preservation : Wp.WpPropId.prop_id -> Cil_types.stmt option
      val is_smoke_test : Wp.WpPropId.prop_id -> bool
      val select_default : Wp.WpPropId.prop_id -> bool
      val select_by_name : string list -> Wp.WpPropId.prop_id -> bool
      val select_for_behaviors : string list -> Wp.WpPropId.prop_id -> bool
      val select_call_pre :
        Cil_types.stmt -> Property.t option -> Wp.WpPropId.prop_id -> bool
      val ident_names : string list -> string list
      val prop_id_keys : Wp.WpPropId.prop_id -> string list * string list
      val get_propid : Wp.WpPropId.prop_id -> string
      val pp_propid : Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
      val user_pred_names : Cil_types.toplevel_predicate -> string list
      val user_bhv_names : Property.identified_property -> string list
      val user_prop_names : Property.identified_property -> string list
      val are_selected_names : string list -> string list -> bool
      val pretty : Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
      val pretty_context :
        Description.kf ->
        Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
      val pretty_local :
        Stdlib.Format.formatter -> Wp.WpPropId.prop_id -> unit
      val label_of_prop_id : Wp.WpPropId.prop_id -> string
      val string_of_termination_kind : Cil_types.termination_kind -> string
      val num_of_bhv_from : Cil_types.funbehavior -> Cil_types.from -> int
      val mk_smoke :
        Cil_types.kernel_function ->
        id:string ->
        ?doomed:Property.t list ->
        ?unreachable:Cil_types.stmt -> unit -> Wp.WpPropId.prop_id
      val mk_code_annot_ids :
        Cil_types.kernel_function ->
        Cil_types.stmt ->
        Cil_types.code_annotation -> Wp.WpPropId.prop_id list
      val mk_assert_id :
        Cil_types.kernel_function ->
        Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
      val mk_loop_inv_id :
        Cil_types.kernel_function ->
        Cil_types.stmt ->
        established:bool -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
      val mk_loop_inv :
        Cil_types.kernel_function ->
        Cil_types.stmt ->
        Cil_types.code_annotation ->
        Wp.WpPropId.prop_id * Wp.WpPropId.prop_id
      val mk_inv_hyp_id :
        Cil_types.kernel_function ->
        Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
      val mk_var_decr_id :
        Cil_types.kernel_function ->
        Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
      val mk_var_pos_id :
        Cil_types.kernel_function ->
        Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
      val mk_var_id :
        Cil_types.kernel_function ->
        Cil_types.stmt -> Cil_types.code_annotation -> Wp.WpPropId.prop_id
      val mk_loop_from_id :
        Cil_types.kernel_function ->
        Cil_types.stmt ->
        Cil_types.code_annotation -> Cil_types.from -> Wp.WpPropId.prop_id
      val mk_bhv_from_id :
        Cil_types.kernel_function ->
        Cil_types.kinstr ->
        string list ->
        Cil_types.funbehavior -> Cil_types.from -> Wp.WpPropId.prop_id
      val mk_fct_from_id :
        Cil_types.kernel_function ->
        bool ->
        Cil_types.funbehavior ->
        Cil_types.termination_kind -> Cil_types.from -> Wp.WpPropId.prop_id
      val mk_disj_bhv_id :
        Cil_types.kernel_function * Cil_types.kinstr * string list *
        string list -> Wp.WpPropId.prop_id
      val mk_compl_bhv_id :
        Cil_types.kernel_function * Cil_types.kinstr * string list *
        string list -> Wp.WpPropId.prop_id
      val mk_decrease_id :
        Cil_types.kernel_function ->
        Cil_types.kinstr -> Cil_types.variant -> Wp.WpPropId.prop_id
      val mk_lemma_id : Wp.LogicUsage.logic_lemma -> Wp.WpPropId.prop_id
      val mk_stmt_assigns_id :
        Cil_types.kernel_function ->
        Cil_types.stmt ->
        string list ->
        Cil_types.funbehavior ->
        Cil_types.from list -> Wp.WpPropId.prop_id option
      val mk_loop_assigns_id :
        Cil_types.kernel_function ->
        Cil_types.stmt ->
        Cil_types.code_annotation ->
        Cil_types.from list -> Wp.WpPropId.prop_id option
      val mk_fct_assigns_id :
        Cil_types.kernel_function ->
        bool ->
        Cil_types.funbehavior ->
        Cil_types.termination_kind ->
        Cil_types.from list -> Wp.WpPropId.prop_id option
      val mk_pre_id :
        Cil_types.kernel_function ->
        Cil_types.kinstr ->
        Cil_types.funbehavior ->
        Cil_types.identified_predicate -> Wp.WpPropId.prop_id
      val mk_post_id :
        Cil_types.kernel_function ->
        Cil_types.kinstr ->
        Cil_types.funbehavior ->
        Cil_types.termination_kind * Cil_types.identified_predicate ->
        Wp.WpPropId.prop_id
      val mk_terminates_id :
        Cil_types.kernel_function ->
        Cil_types.kinstr ->
        Cil_types.identified_predicate -> Wp.WpPropId.prop_id
      val mk_stmt_post_id :
        Cil_types.kernel_function ->
        Cil_types.stmt ->
        Cil_types.funbehavior ->
        Cil_types.termination_kind * Cil_types.identified_predicate ->
        Wp.WpPropId.prop_id
      val mk_fct_post_id :
        Cil_types.kernel_function ->
        Cil_types.funbehavior ->
        Cil_types.termination_kind * Cil_types.identified_predicate ->
        Wp.WpPropId.prop_id
      val mk_call_pre_id :
        Cil_types.kernel_function ->
        Cil_types.stmt -> Property.t -> Property.t -> Wp.WpPropId.prop_id
      val mk_property : Property.t -> Wp.WpPropId.prop_id
      val mk_check : Property.t -> Wp.WpPropId.prop_id
      type a_kind = LoopAssigns | StmtAssigns
      type assigns_desc = private {
        a_label : Wp.Clabels.c_label;
        a_stmt : Cil_types.stmt option;
        a_kind : Wp.WpPropId.a_kind;
        a_assigns : Cil_types.assigns;
      }
      val pp_assigns_desc :
        Stdlib.Format.formatter -> Wp.WpPropId.assigns_desc -> unit
      type effect_source = FromCode | FromCall | FromReturn
      type assigns_info = Wp.WpPropId.prop_id * Wp.WpPropId.assigns_desc
      val assigns_info_id : Wp.WpPropId.assigns_info -> Wp.WpPropId.prop_id
      type assigns_full_info = private
          AssignsLocations of Wp.WpPropId.assigns_info
        | AssignsAny of Wp.WpPropId.assigns_desc
        | NoAssignsInfo
      val empty_assigns_info : Wp.WpPropId.assigns_full_info
      val mk_assigns_info :
        Wp.WpPropId.prop_id ->
        Wp.WpPropId.assigns_desc -> Wp.WpPropId.assigns_full_info
      val mk_stmt_any_assigns_info :
        Cil_types.stmt -> Wp.WpPropId.assigns_full_info
      val mk_kf_any_assigns_info : unit -> Wp.WpPropId.assigns_full_info
      val mk_loop_any_assigns_info :
        Cil_types.stmt -> Wp.WpPropId.assigns_full_info
      val pp_assign_info :
        string ->
        Stdlib.Format.formatter -> Wp.WpPropId.assigns_full_info -> unit
      val merge_assign_info :
        Wp.WpPropId.assigns_full_info ->
        Wp.WpPropId.assigns_full_info -> Wp.WpPropId.assigns_full_info
      val mk_loop_assigns_desc :
        Cil_types.stmt -> Cil_types.from list -> Wp.WpPropId.assigns_desc
      val mk_stmt_assigns_desc :
        Cil_types.stmt -> Cil_types.from list -> Wp.WpPropId.assigns_desc
      val mk_stmt_assigns_any_desc :
        Cil_types.stmt -> Wp.WpPropId.assigns_desc
      val mk_asm_assigns_desc : Cil_types.stmt -> Wp.WpPropId.assigns_desc
      val mk_kf_assigns_desc :
        Cil_types.from list -> Wp.WpPropId.assigns_desc
      val mk_init_assigns : Wp.WpPropId.assigns_desc
      val is_call_assigns : Wp.WpPropId.assigns_desc -> bool
      type axiom_info = Wp.WpPropId.prop_id * Wp.LogicUsage.logic_lemma
      val mk_axiom_info : Wp.LogicUsage.logic_lemma -> Wp.WpPropId.axiom_info
      val pp_axiom_info :
        Stdlib.Format.formatter -> Wp.WpPropId.axiom_info -> unit
      type pred_info = Wp.WpPropId.prop_id * Cil_types.predicate
      type variant_info = Wp.WpPropId.prop_id * Cil_types.variant
      val mk_pred_info :
        Wp.WpPropId.prop_id -> Cil_types.predicate -> Wp.WpPropId.pred_info
      val pred_info_id : Wp.WpPropId.pred_info -> Wp.WpPropId.prop_id
      val pp_pred_of_pred_info :
        Stdlib.Format.formatter -> Wp.WpPropId.pred_info -> unit
      val pp_pred_info :
        Stdlib.Format.formatter -> Wp.WpPropId.pred_info -> unit
      val split_bag :
        (Wp.WpPropId.prop_id -> '-> unit) ->
        Wp.WpPropId.prop_id -> 'Bag.t -> unit
      val split_map :
        (Wp.WpPropId.prop_id -> '-> 'b) ->
        Wp.WpPropId.prop_id -> 'a list -> 'b list
      val mk_part : Wp.WpPropId.prop_id -> int * int -> Wp.WpPropId.prop_id
      val parts_of_id : Wp.WpPropId.prop_id -> (int * int) option
      val subproofs : Wp.WpPropId.prop_id -> int
      val subproof_idx : Wp.WpPropId.prop_id -> int
      val get_induction : Wp.WpPropId.prop_id -> Cil_types.stmt option
      type proof
      val create_proof : Wp.WpPropId.prop_id -> Wp.WpPropId.proof
      val add_proof :
        Wp.WpPropId.proof -> Wp.WpPropId.prop_id -> Property.t list -> unit
      val add_invalid_proof : Wp.WpPropId.proof -> unit
      val is_composed : Wp.WpPropId.proof -> bool
      val is_proved : Wp.WpPropId.proof -> bool
      val is_invalid : Wp.WpPropId.proof -> bool
      val target : Wp.WpPropId.proof -> Property.t
      val dependencies : Wp.WpPropId.proof -> Property.t list
      val filter_status : Wp.WpPropId.prop_id -> bool
    end
  module Mcfg :
    sig
      type scope =
          SC_Global
        | SC_Frame_in
        | SC_Frame_out
        | SC_Block_in
        | SC_Block_out
      module type Export =
        sig
          type pred
          type decl
          val export_section : Stdlib.Format.formatter -> string -> unit
          val export_goal :
            Stdlib.Format.formatter -> string -> Wp.Mcfg.Export.pred -> unit
          val export_decl :
            Stdlib.Format.formatter -> Wp.Mcfg.Export.decl -> unit
        end
      module type Splitter =
        sig
          type pred
          val simplify : Wp.Mcfg.Splitter.pred -> Wp.Mcfg.Splitter.pred
          val split :
            bool -> Wp.Mcfg.Splitter.pred -> Wp.Mcfg.Splitter.pred Bag.t
        end
      module type S =
        sig
          type t_env
          type t_prop
          val pretty : Stdlib.Format.formatter -> Wp.Mcfg.S.t_prop -> unit
          val merge :
            Wp.Mcfg.S.t_env ->
            Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val empty : Wp.Mcfg.S.t_prop
          val new_env :
            ?lvars:Cil_types.logic_var list ->
            Cil_types.kernel_function -> Wp.Mcfg.S.t_env
          val add_axiom :
            Wp.WpPropId.prop_id -> Wp.LogicUsage.logic_lemma -> unit
          val add_hyp :
            ?for_pid:Wp.WpPropId.prop_id ->
            Wp.Mcfg.S.t_env ->
            Wp.WpPropId.pred_info -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val add_goal :
            Wp.Mcfg.S.t_env ->
            Wp.WpPropId.pred_info -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val add_subgoal :
            Wp.Mcfg.S.t_env ->
            Wp.WpPropId.prop_id * '->
            ?deps:Property.Set.t ->
            Cil_types.predicate ->
            Cil_types.stmt ->
            Wp.WpPropId.effect_source -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val add_assigns :
            Wp.Mcfg.S.t_env ->
            Wp.WpPropId.assigns_info -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val use_assigns :
            Wp.Mcfg.S.t_env ->
            Wp.WpPropId.prop_id option ->
            Wp.WpPropId.assigns_desc -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val label :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt option ->
            Wp.Clabels.c_label -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val init :
            Wp.Mcfg.S.t_env ->
            Cil_types.varinfo ->
            Cil_types.init option -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val const :
            Wp.Mcfg.S.t_env ->
            Cil_types.varinfo -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val assign :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.lval ->
            Cil_types.exp -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val return :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.exp option -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val test :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.exp ->
            Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val switch :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.exp ->
            (Cil_types.exp list * Wp.Mcfg.S.t_prop) list ->
            Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val has_init : Wp.Mcfg.S.t_env -> bool
          val loop_entry : Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val loop_step : Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val call_dynamic :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Wp.WpPropId.prop_id ->
            Cil_types.exp ->
            (Cil_types.kernel_function * Wp.Mcfg.S.t_prop) list ->
            Wp.Mcfg.S.t_prop
          val call_goal_precond :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.kernel_function ->
            Cil_types.exp list ->
            pre:Wp.WpPropId.pred_info list ->
            Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val call_terminates :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.kernel_function ->
            Cil_types.exp list ->
            Wp.WpPropId.pred_info ->
            ?callee_t:Cil_types.predicate ->
            Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val call_decreases :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.kernel_function ->
            Cil_types.exp list ->
            Wp.WpPropId.variant_info ->
            ?caller_t:Cil_types.predicate ->
            ?callee_d:Cil_types.variant ->
            Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val call :
            Wp.Mcfg.S.t_env ->
            Cil_types.stmt ->
            Cil_types.lval option ->
            Cil_types.kernel_function ->
            Cil_types.exp list ->
            pre:Wp.WpPropId.pred_info list ->
            post:Wp.WpPropId.pred_info list ->
            pexit:Wp.WpPropId.pred_info list ->
            assigns:Cil_types.assigns ->
            p_post:Wp.Mcfg.S.t_prop ->
            p_exit:Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val scope :
            Wp.Mcfg.S.t_env ->
            Cil_types.varinfo list ->
            Wp.Mcfg.scope -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val close : Wp.Mcfg.S.t_env -> Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
          val build_prop_of_from :
            Wp.Mcfg.S.t_env ->
            Wp.WpPropId.pred_info list ->
            Wp.Mcfg.S.t_prop -> Wp.Mcfg.S.t_prop
        end
    end
  module Context :
    sig
      val with_current_loc : Cil_types.location -> ('-> 'b) -> '-> 'b
      type 'a value
      val create : ?default:'-> string -> 'Wp.Context.value
      val defined : 'Wp.Context.value -> bool
      val get : 'Wp.Context.value -> 'a
      val get_opt : 'Wp.Context.value -> 'a option
      val set : 'Wp.Context.value -> '-> unit
      val update : 'Wp.Context.value -> ('-> 'a) -> unit
      val bind : 'Wp.Context.value -> '-> ('-> 'c) -> '-> 'c
      val free : 'Wp.Context.value -> ('-> 'c) -> '-> 'c
      val clear : 'Wp.Context.value -> unit
      val push : 'Wp.Context.value -> '-> 'a option
      val pop : 'Wp.Context.value -> 'a option -> unit
      val name : 'Wp.Context.value -> string
      val register : (unit -> unit) -> unit
      val configure : unit -> unit
    end
  module Warning :
    sig
      exception Error of string * string
      val error :
        ?source:string ->
        ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
      type t = {
        loc : Filepath.position;
        severe : bool;
        source : string;
        reason : string;
        effect : string;
      }
      val compare : Wp.Warning.t -> Wp.Warning.t -> int
      val pretty : Stdlib.Format.formatter -> Wp.Warning.t -> unit
      module Set :
        sig
          type elt = t
          type t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val disjoint : t -> t -> bool
          val diff : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val map : (elt -> elt) -> t -> t
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val filter_map : (elt -> elt option) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_list : elt list -> t
          val to_seq_from : elt -> t -> elt Seq.t
          val to_seq : t -> elt Seq.t
          val to_rev_seq : t -> elt Seq.t
          val add_seq : elt Seq.t -> t -> t
          val of_seq : elt Seq.t -> t
        end
      module Map :
        sig
          type key = t
          type +!'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
      val severe : Wp.Warning.Set.t -> bool
      type context
      val context : ?source:string -> unit -> Wp.Warning.context
      val flush : Wp.Warning.context -> Wp.Warning.Set.t
      val add : Wp.Warning.t -> unit
      val create :
        ?log:bool ->
        ?severe:bool ->
        ?source:string ->
        effect:string ->
        ('a, Stdlib.Format.formatter, unit, Wp.Warning.t) Stdlib.format4 ->
        'a
      val emit :
        ?severe:bool ->
        ?source:string ->
        effect:string ->
        ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
      val handle :
        ?severe:bool ->
        effect:string -> handler:('-> 'b) -> ('-> 'b) -> '-> 'b
      type 'a outcome =
          Result of Wp.Warning.Set.t * 'a
        | Failed of Wp.Warning.Set.t
      val catch :
        ?source:string ->
        ?severe:bool ->
        effect:string -> ('-> 'b) -> '-> 'Wp.Warning.outcome
    end
  module AssignsCompleteness :
    sig
      val compute : Kernel_function.t -> unit
      val is_complete : Kernel_function.t -> bool
      val warn : Kernel_function.t -> unit
      val wkey_pedantic : Wp.Wp_parameters.warn_category
    end
  module WpContext :
    sig
      type model
      type scope = Global | Kf of Kernel_function.t
      type rollback = unit -> unit
      type hypotheses =
          Wp.MemoryContext.partition -> Wp.MemoryContext.partition
      val register :
        id:string ->
        ?descr:string ->
        configure:(unit -> Wp.WpContext.rollback) ->
        ?hypotheses:Wp.WpContext.hypotheses -> unit -> Wp.WpContext.model
      val get_descr : Wp.WpContext.model -> string
      val get_emitter : Wp.WpContext.model -> Emitter.t
      val compute_hypotheses :
        Wp.WpContext.model -> Kernel_function.t -> Wp.MemoryContext.partition
      type context = Wp.WpContext.model * Wp.WpContext.scope
      type t = Wp.WpContext.context
      module S :
        sig
          type t = Wp.WpContext.context
          val id : Wp.WpContext.S.t -> string
          val hash : Wp.WpContext.S.t -> int
          val equal : Wp.WpContext.S.t -> Wp.WpContext.S.t -> bool
          val compare : Wp.WpContext.S.t -> Wp.WpContext.S.t -> int
        end
      module MODEL :
        sig
          type t = Wp.WpContext.model
          val id : Wp.WpContext.MODEL.t -> string
          val descr : Wp.WpContext.MODEL.t -> string
          val hash : Wp.WpContext.MODEL.t -> int
          val equal : Wp.WpContext.MODEL.t -> Wp.WpContext.MODEL.t -> bool
          val compare : Wp.WpContext.MODEL.t -> Wp.WpContext.MODEL.t -> int
          val repr : Wp.WpContext.MODEL.t
        end
      module SCOPE :
        sig
          type t = Wp.WpContext.scope
          val id : Wp.WpContext.SCOPE.t -> string
          val hash : Wp.WpContext.SCOPE.t -> int
          val equal : Wp.WpContext.SCOPE.t -> Wp.WpContext.SCOPE.t -> bool
          val compare : Wp.WpContext.SCOPE.t -> Wp.WpContext.SCOPE.t -> int
        end
      module MINDEX :
        sig
          type key = model
          type !'a t
          val create : int -> 'a t
          val clear : 'a t -> unit
          val reset : '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_opt : 'a t -> key -> 'a option
          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 filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val length : 'a t -> int
          val stats : 'a t -> Hashtbl.statistics
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_keys : 'a t -> key Seq.t
          val to_seq_values : 'a t -> 'Seq.t
          val add_seq : 'a t -> (key * 'a) Seq.t -> unit
          val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
      val is_defined : unit -> bool
      val on_context : Wp.WpContext.context -> ('-> 'b) -> '-> 'b
      val get_model : unit -> Wp.WpContext.model
      val get_scope : unit -> Wp.WpContext.scope
      val get_context : unit -> Wp.WpContext.context
      val directory : unit -> Datatype.Filepath.t
      module type Entries =
        sig
          type key
          type data
          val name : string
          val compare :
            Wp.WpContext.Entries.key -> Wp.WpContext.Entries.key -> int
          val pretty :
            Stdlib.Format.formatter -> Wp.WpContext.Entries.key -> unit
        end
      module type Registry =
        sig
          module E : Entries
          type key = E.key
          type data = E.data
          val id : basename:string -> Wp.WpContext.Registry.key -> string
          val mem : Wp.WpContext.Registry.key -> bool
          val find : Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data
          val get :
            Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data option
          val clear : unit -> unit
          val remove : Wp.WpContext.Registry.key -> unit
          val define :
            Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit
          val update :
            Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit
          val memoize :
            (Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data) ->
            Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data
          val compile :
            (Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data) ->
            Wp.WpContext.Registry.key -> unit
          val callback :
            (Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit) ->
            unit
          val iter :
            (Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit) ->
            unit
          val iter_sorted :
            (Wp.WpContext.Registry.key -> Wp.WpContext.Registry.data -> unit) ->
            unit
        end
      module Index :
        functor (E : Entries->
          sig
            module E :
              sig
                type key = E.key
                type data = E.data
                val name : string
                val compare : key -> key -> int
                val pretty : Format.formatter -> key -> unit
              end
            type key = E.key
            type data = E.data
            val id : basename:string -> key -> string
            val mem : key -> bool
            val find : key -> data
            val get : key -> data option
            val clear : unit -> unit
            val remove : key -> unit
            val define : key -> data -> unit
            val update : key -> data -> unit
            val memoize : (key -> data) -> key -> data
            val compile : (key -> data) -> key -> unit
            val callback : (key -> data -> unit) -> unit
            val iter : (key -> data -> unit) -> unit
            val iter_sorted : (key -> data -> unit) -> unit
          end
      module Static :
        functor (E : Entries->
          sig
            module E :
              sig
                type key = E.key
                type data = E.data
                val name : string
                val compare : key -> key -> int
                val pretty : Format.formatter -> key -> unit
              end
            type key = E.key
            type data = E.data
            val id : basename:string -> key -> string
            val mem : key -> bool
            val find : key -> data
            val get : key -> data option
            val clear : unit -> unit
            val remove : key -> unit
            val define : key -> data -> unit
            val update : key -> data -> unit
            val memoize : (key -> data) -> key -> data
            val compile : (key -> data) -> key -> unit
            val callback : (key -> data -> unit) -> unit
            val iter : (key -> data -> unit) -> unit
            val iter_sorted : (key -> data -> unit) -> unit
          end
      module type Key =
        sig
          type t
          val compare : Wp.WpContext.Key.t -> Wp.WpContext.Key.t -> int
          val pretty : Stdlib.Format.formatter -> Wp.WpContext.Key.t -> unit
        end
      module type Data =
        sig
          type key
          type data
          val name : string
          val compile : Wp.WpContext.Data.key -> Wp.WpContext.Data.data
        end
      module type IData =
        sig
          type key
          type data
          val name : string
          val basename : Wp.WpContext.IData.key -> string
          val compile :
            Wp.WpContext.IData.key -> string -> Wp.WpContext.IData.data
        end
      module type Generator =
        sig
          type key
          type data
          val get : Wp.WpContext.Generator.key -> Wp.WpContext.Generator.data
          val mem : Wp.WpContext.Generator.key -> bool
          val clear : unit -> unit
          val remove : Wp.WpContext.Generator.key -> unit
        end
      module Generator :
        functor (K : Key)
          (D : sig
                 type key = K.t
                 type data
                 val name : string
                 val compile : key -> data
               end)
          ->
          sig
            type key = D.key
            type data = D.data
            val get : key -> data
            val mem : key -> bool
            val clear : unit -> unit
            val remove : key -> unit
          end
      module StaticGenerator :
        functor (K : Key)
          (D : sig
                 type key = K.t
                 type data
                 val name : string
                 val compile : key -> data
               end)
          ->
          sig
            type key = D.key
            type data = D.data
            val get : key -> data
            val mem : key -> bool
            val clear : unit -> unit
            val remove : key -> unit
          end
      module GeneratorID :
        functor (K : Key)
          (D : sig
                 type key = K.t
                 type data
                 val name : string
                 val basename : key -> string
                 val compile : key -> string -> data
               end)
          ->
          sig
            type key = D.key
            type data = D.data
            val get : key -> data
            val mem : key -> bool
            val clear : unit -> unit
            val remove : key -> unit
          end
      module StaticGeneratorID :
        functor (K : Key)
          (D : sig
                 type key = K.t
                 type data
                 val name : string
                 val basename : key -> string
                 val compile : key -> string -> data
               end)
          ->
          sig
            type key = D.key
            type data = D.data
            val get : key -> data
            val mem : key -> bool
            val clear : unit -> unit
            val remove : key -> unit
          end
    end
  module Lang :
    sig
      type library = string
      val comp_id : Cil_types.compinfo -> string
      val comp_init_id : Cil_types.compinfo -> string
      val field_id : Cil_types.fieldinfo -> string
      val field_init_id : Cil_types.fieldinfo -> string
      val type_id : Cil_types.logic_type_info -> string
      val logic_id : Cil_types.logic_info -> string
      val ctor_id : Cil_types.logic_ctor_info -> string
      val lemma_id : string -> string
      type datakind = KValue | KInit
      type adt = private
          Mtype of Wp.Lang.mdt
        | Mrecord of Wp.Lang.mdt * Wp.Lang.fields
        | Atype of Cil_types.logic_type_info
        | Comp of Cil_types.compinfo * Wp.Lang.datakind
      and mdt = string Wp.Lang.extern
      and 'a extern = {
        ext_id : int;
        ext_link : 'a;
        ext_library : Wp.Lang.library;
        ext_debug : string;
      }
      and fields = { mutable fields : Wp.Lang.field list; }
      and field =
          Mfield of Wp.Lang.mdt * Wp.Lang.fields * string * Wp.Lang.tau
        | Cfield of Cil_types.fieldinfo * Wp.Lang.datakind
      and tau = (Wp.Lang.field, Wp.Lang.adt) Qed.Logic.datatype
      type t_builtin =
          E_mdt of Wp.Lang.mdt
        | E_poly of (Wp.Lang.tau list -> Wp.Lang.tau)
      type lfun =
          ACSL of Cil_types.logic_info
        | CTOR of Cil_types.logic_ctor_info
        | Model of Wp.Lang.model
      and model = {
        m_category : Wp.Lang.lfun Qed.Logic.category;
        m_params : Qed.Logic.sort list;
        m_result : Qed.Logic.sort;
        m_typeof : Wp.Lang.tau option list -> Wp.Lang.tau;
        m_source : Wp.Lang.source;
        m_coloring : bool;
      }
      and source =
          Generated of Wp.WpContext.context option * string
        | Extern of Qed.Engine.link Wp.Lang.extern
      val mem_builtin_type : name:string -> bool
      val is_builtin : Cil_types.logic_type_info -> bool
      val is_builtin_type : name:string -> Wp.Lang.tau -> bool
      val get_builtin_type : name:string -> Wp.Lang.adt
      val datatype : library:string -> string -> Wp.Lang.adt
      val record :
        link:string ->
        library:string -> (string * Wp.Lang.tau) list -> Wp.Lang.adt
      val comp : Cil_types.compinfo -> Wp.Lang.adt
      val comp_init : Cil_types.compinfo -> Wp.Lang.adt
      val field : Wp.Lang.adt -> string -> Wp.Lang.field
      val fields_of_adt : Wp.Lang.adt -> Wp.Lang.field list
      val fields_of_tau : Wp.Lang.tau -> Wp.Lang.field list
      val fields_of_field : Wp.Lang.field -> Wp.Lang.field list
      val atype :
        Cil_types.logic_type_info -> Wp.Lang.tau list -> Wp.Lang.tau
      val adt : Cil_types.logic_type_info -> Wp.Lang.adt
      type balance = Nary | Left | Right
      val extern_s :
        library:Wp.Lang.library ->
        ?link:Qed.Engine.link ->
        ?category:Wp.Lang.lfun Qed.Logic.category ->
        ?params:Qed.Logic.sort list ->
        ?sort:Qed.Logic.sort ->
        ?result:Wp.Lang.tau ->
        ?coloring:bool ->
        ?typecheck:(Wp.Lang.tau option list -> Wp.Lang.tau) ->
        string -> Wp.Lang.lfun
      val extern_f :
        library:Wp.Lang.library ->
        ?link:Qed.Engine.link ->
        ?balance:Wp.Lang.balance ->
        ?category:Wp.Lang.lfun Qed.Logic.category ->
        ?params:Qed.Logic.sort list ->
        ?sort:Qed.Logic.sort ->
        ?result:Wp.Lang.tau ->
        ?coloring:bool ->
        ?typecheck:(Wp.Lang.tau option list -> Wp.Lang.tau) ->
        ('a, Stdlib.Format.formatter, unit, Wp.Lang.lfun) Stdlib.format4 ->
        'a
      val extern_p :
        library:Wp.Lang.library ->
        ?bool:string ->
        ?prop:string ->
        ?link:Qed.Engine.link ->
        ?params:Qed.Logic.sort list -> ?coloring:bool -> unit -> Wp.Lang.lfun
      val extern_fp :
        library:Wp.Lang.library ->
        ?params:Qed.Logic.sort list ->
        ?link:string -> ?coloring:bool -> string -> Wp.Lang.lfun
      val generated_f :
        ?context:bool ->
        ?category:Wp.Lang.lfun Qed.Logic.category ->
        ?params:Qed.Logic.sort list ->
        ?sort:Qed.Logic.sort ->
        ?result:Wp.Lang.tau ->
        ?coloring:bool ->
        ('a, Stdlib.Format.formatter, unit, Wp.Lang.lfun) Stdlib.format4 ->
        'a
      val generated_p :
        ?context:bool -> ?coloring:bool -> string -> Wp.Lang.lfun
      val extern_t :
        string -> link:string -> library:Wp.Lang.library -> Wp.Lang.mdt
      val tau_of_object : Wp.Ctypes.c_object -> Wp.Lang.tau
      val tau_of_ctype : Cil_types.typ -> Wp.Lang.tau
      val tau_of_ltype : Cil_types.logic_type -> Wp.Lang.tau
      val tau_of_return : Cil_types.logic_info -> Wp.Lang.tau
      val tau_of_lfun :
        Wp.Lang.lfun -> Wp.Lang.tau option list -> Wp.Lang.tau
      val tau_of_field : Wp.Lang.field -> Wp.Lang.tau
      val tau_of_record : Wp.Lang.field -> Wp.Lang.tau
      val init_of_object : Wp.Ctypes.c_object -> Wp.Lang.tau
      val init_of_ctype : Cil_types.typ -> Wp.Lang.tau
      val t_int : Wp.Lang.tau
      val t_real : Wp.Lang.tau
      val t_bool : Wp.Lang.tau
      val t_prop : Wp.Lang.tau
      val t_addr : unit -> Wp.Lang.tau
      val t_comp : Cil_types.compinfo -> Wp.Lang.tau
      val t_init : Cil_types.compinfo -> Wp.Lang.tau
      val t_float : Wp.Ctypes.c_float -> Wp.Lang.tau
      val t_array : Wp.Lang.tau -> Wp.Lang.tau
      val t_farray : Wp.Lang.tau -> Wp.Lang.tau -> Wp.Lang.tau
      val t_datatype : Wp.Lang.adt -> Wp.Lang.tau list -> Wp.Lang.tau
      val t_matrix : Wp.Lang.tau -> int -> Wp.Lang.tau
      val pointer : Wp.Lang.tau Wp.Context.value
      val floats : (Wp.Ctypes.c_float -> Wp.Lang.tau) Wp.Context.value
      val poly : string list Wp.Context.value
      val builtin_types : (string -> Wp.Lang.t_builtin) Wp.Context.value
      val parameters : (Wp.Lang.lfun -> Qed.Logic.sort list) -> unit
      val name_of_lfun : Wp.Lang.lfun -> string
      val name_of_field : Wp.Lang.field -> string
      val is_coloring_lfun : Wp.Lang.lfun -> bool
      module ADT :
        sig
          type t = adt
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val pretty : Format.formatter -> t -> unit
          val debug : t -> string
          val basename : t -> string
        end
      module Field :
        sig
          type t = field
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val pretty : Format.formatter -> t -> unit
          val debug : t -> string
          val sort : t -> Qed.Logic.sort
        end
      module Fun :
        sig
          type t = lfun
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val pretty : Format.formatter -> t -> unit
          val debug : t -> string
          val category : t -> t Qed.Logic.category
          val params : t -> Qed.Logic.sort list
          val sort : t -> Qed.Logic.sort
        end
      class virtual idprinting :
        object
          method datatype : Wp.Lang.ADT.t -> string
          method field : Wp.Lang.Field.t -> string
          method link : Wp.Lang.Fun.t -> Qed.Engine.link
          method virtual sanitize : string -> string
          method sanitize_field : string -> string
          method sanitize_fun : string -> string
          method sanitize_type : string -> string
        end
      module F :
        sig
          module QED :
            sig
              module ADT :
                sig
                  type t = adt
                  val hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val pretty : Format.formatter -> t -> unit
                  val debug : t -> string
                  val basename : t -> string
                end
              module Field :
                sig
                  type t = field
                  val hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val pretty : Format.formatter -> t -> unit
                  val debug : t -> string
                  val sort : t -> Qed.Logic.sort
                end
              module Fun :
                sig
                  type t = lfun
                  val hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val pretty : Format.formatter -> t -> unit
                  val debug : t -> string
                  val category : t -> t Qed.Logic.category
                  val params : t -> Qed.Logic.sort list
                  val sort : t -> Qed.Logic.sort
                end
              module Var : Qed.Logic.Variable
              type term
              type lc_term
              module Term :
                sig
                  type t = term
                  val hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val pretty : Format.formatter -> t -> unit
                  val debug : t -> string
                end
              module Tset :
                sig
                  type elt = term
                  type t
                  val empty : t
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val find : elt -> t -> elt
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val remove : elt -> t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val compare : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val filter : (elt -> bool) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val cardinal : t -> int
                  val elements : t -> elt list
                  val map : (elt -> elt) -> t -> t
                  val mapf : (elt -> elt option) -> t -> t
                  val intersect : t -> t -> bool
                end
              module Tmap :
                sig
                  type key = term
                  type 'a t
                  val is_empty : 'a t -> bool
                  val empty : 'a t
                  val add : key -> '-> 'a t -> 'a t
                  val mem : key -> 'a t -> bool
                  val find : key -> 'a t -> 'a
                  val remove : key -> 'a t -> 'a t
                  val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val map : (key -> '-> 'b) -> 'a t -> 'b t
                  val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                  val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                  val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val interf :
                    (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                  val interq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val diffq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  val iter2 :
                    (key -> 'a option -> 'b option -> unit) ->
                    'a t -> 'b t -> unit
                  val subset :
                    (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                  val insert :
                    (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                  val change :
                    (key -> '-> 'a option -> 'a option) ->
                    key -> '-> 'a t -> 'a t
                end
              module STset :
                sig
                  type elt = term
                  type t
                  val empty : t
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val remove : elt -> t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val disjoint : t -> t -> bool
                  val diff : t -> t -> t
                  val compare : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val map : (elt -> elt) -> t -> t
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val filter : (elt -> bool) -> t -> t
                  val filter_map : (elt -> elt option) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val cardinal : t -> int
                  val elements : t -> elt list
                  val min_elt : t -> elt
                  val min_elt_opt : t -> elt option
                  val max_elt : t -> elt
                  val max_elt_opt : t -> elt option
                  val choose : t -> elt
                  val choose_opt : t -> elt option
                  val split : elt -> t -> t * bool * t
                  val find : elt -> t -> elt
                  val find_opt : elt -> t -> elt option
                  val find_first : (elt -> bool) -> t -> elt
                  val find_first_opt : (elt -> bool) -> t -> elt option
                  val find_last : (elt -> bool) -> t -> elt
                  val find_last_opt : (elt -> bool) -> t -> elt option
                  val of_list : elt list -> t
                  val to_seq_from : elt -> t -> elt Seq.t
                  val to_seq : t -> elt Seq.t
                  val to_rev_seq : t -> elt Seq.t
                  val add_seq : elt Seq.t -> t -> t
                  val of_seq : elt Seq.t -> t
                end
              module STmap :
                sig
                  type key = term
                  type +!'a t
                  val empty : 'a t
                  val is_empty : 'a t -> bool
                  val mem : key -> 'a t -> bool
                  val add : key -> '-> 'a t -> 'a t
                  val update :
                    key -> ('a option -> 'a option) -> 'a t -> 'a t
                  val singleton : key -> '-> 'a t
                  val remove : key -> 'a t -> 'a t
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  val union :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val for_all : (key -> '-> bool) -> 'a t -> bool
                  val exists : (key -> '-> bool) -> 'a t -> bool
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val cardinal : 'a t -> int
                  val bindings : 'a t -> (key * 'a) list
                  val min_binding : 'a t -> key * 'a
                  val min_binding_opt : 'a t -> (key * 'a) option
                  val max_binding : 'a t -> key * 'a
                  val max_binding_opt : 'a t -> (key * 'a) option
                  val choose : 'a t -> key * 'a
                  val choose_opt : 'a t -> (key * 'a) option
                  val split : key -> 'a t -> 'a t * 'a option * 'a t
                  val find : key -> 'a t -> 'a
                  val find_opt : key -> 'a t -> 'a option
                  val find_first : (key -> bool) -> 'a t -> key * 'a
                  val find_first_opt :
                    (key -> bool) -> 'a t -> (key * 'a) option
                  val find_last : (key -> bool) -> 'a t -> key * 'a
                  val find_last_opt :
                    (key -> bool) -> 'a t -> (key * 'a) option
                  val map : ('-> 'b) -> 'a t -> 'b t
                  val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                  val to_seq : 'a t -> (key * 'a) Seq.t
                  val to_rev_seq : 'a t -> (key * 'a) Seq.t
                  val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
                  val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
                  val of_seq : (key * 'a) Seq.t -> 'a t
                end
              type var = Var.t
              type tau = (Field.t, ADT.t) Qed.Logic.datatype
              module Tau :
                sig
                  type t = tau
                  val hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val pretty : Format.formatter -> t -> unit
                  val debug : t -> string
                  val basename : t -> string
                end
              module Vars :
                sig
                  type elt = var
                  type t
                  val empty : t
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val find : elt -> t -> elt
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val remove : elt -> t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val compare : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val filter : (elt -> bool) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val cardinal : t -> int
                  val elements : t -> elt list
                  val map : (elt -> elt) -> t -> t
                  val mapf : (elt -> elt option) -> t -> t
                  val intersect : t -> t -> bool
                end
              module Vmap :
                sig
                  type key = var
                  type 'a t
                  val is_empty : 'a t -> bool
                  val empty : 'a t
                  val add : key -> '-> 'a t -> 'a t
                  val mem : key -> 'a t -> bool
                  val find : key -> 'a t -> 'a
                  val remove : key -> 'a t -> 'a t
                  val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val map : (key -> '-> 'b) -> 'a t -> 'b t
                  val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                  val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                  val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val interf :
                    (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                  val interq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val diffq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  val iter2 :
                    (key -> 'a option -> 'b option -> unit) ->
                    'a t -> 'b t -> unit
                  val subset :
                    (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                  val insert :
                    (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                  val change :
                    (key -> '-> 'a option -> 'a option) ->
                    key -> '-> 'a t -> 'a t
                end
              type pool
              val pool : ?copy:pool -> unit -> pool
              val add_var : pool -> var -> unit
              val add_vars : pool -> Vars.t -> unit
              val add_term : pool -> term -> unit
              val fresh : pool -> ?basename:string -> tau -> var
              val alpha : pool -> var -> var
              val tau_of_var : var -> tau
              val sort_of_var : var -> Qed.Logic.sort
              val base_of_var : var -> string
              type 'a expression =
                  (Field.t, ADT.t, Fun.t, var, lc_term, 'a)
                  Qed.Logic.term_repr
              type repr = term expression
              type record = (Field.t * term) list
              val decide : term -> bool
              val is_true : term -> Qed.Logic.maybe
              val is_false : term -> Qed.Logic.maybe
              val is_prop : term -> bool
              val is_int : term -> bool
              val is_real : term -> bool
              val is_arith : term -> bool
              val are_equal : term -> term -> Qed.Logic.maybe
              val eval_eq : term -> term -> bool
              val eval_neq : term -> term -> bool
              val eval_lt : term -> term -> bool
              val eval_leq : term -> term -> bool
              val repr : term -> repr
              val sort : term -> Qed.Logic.sort
              val vars : term -> Vars.t
              type path = int list
              val subterm : term -> path -> term
              val change_subterm : term -> path -> term -> term
              val e_true : term
              val e_false : term
              val e_bool : bool -> term
              val e_literal : bool -> term -> term
              val e_int : int -> term
              val e_float : float -> term
              val e_zint : Z.t -> term
              val e_real : Q.t -> term
              val e_var : var -> term
              val e_opp : term -> term
              val e_times : Z.t -> term -> term
              val e_sum : term list -> term
              val e_prod : term list -> term
              val e_add : term -> term -> term
              val e_sub : term -> term -> term
              val e_mul : term -> term -> term
              val e_div : term -> term -> term
              val e_mod : term -> term -> term
              val e_eq : term -> term -> term
              val e_neq : term -> term -> term
              val e_leq : term -> term -> term
              val e_lt : term -> term -> term
              val e_imply : term list -> term -> term
              val e_equiv : term -> term -> term
              val e_and : term list -> term
              val e_or : term list -> term
              val e_not : term -> term
              val e_if : term -> term -> term -> term
              val e_const : tau -> term -> term
              val e_get : term -> term -> term
              val e_set : term -> term -> term -> term
              val e_getfield : term -> Field.t -> term
              val e_record : record -> term
              val e_fun : ?result:tau -> Fun.t -> term list -> term
              val e_repr : ?result:tau -> repr -> term
              val e_forall : var list -> term -> term
              val e_exists : var list -> term -> term
              val e_lambda : var list -> term -> term
              val e_apply : term -> term list -> term
              val e_bind : Qed.Logic.binder -> var -> term -> term
              val lc_open : var -> lc_term -> term
              val e_unbind : var -> lc_term -> term
              val e_open :
                pool:pool ->
                ?forall:bool ->
                ?exists:bool ->
                ?lambda:bool -> term -> (Qed.Logic.binder * var) list * term
              val e_close : (Qed.Logic.binder * var) list -> term -> term
              type sigma
              val sigma : ?pool:pool -> unit -> sigma
              module Subst :
                sig
                  type t = sigma
                  val create : ?pool:pool -> unit -> t
                  val copy : sigma -> sigma
                  val fresh : t -> tau -> var
                  val find : t -> term -> term
                  val filter : t -> term -> bool
                  val add : t -> term -> term -> unit
                  val add_fun : t -> (term -> term) -> unit
                  val add_filter : t -> (term -> bool) -> unit
                  val add_var : t -> var -> unit
                  val add_vars : t -> Vars.t -> unit
                  val add_term : t -> term -> unit
                end
              val e_subst : sigma -> term -> term
              val e_subst_var : var -> term -> term -> term
              val lc_vars : term -> Qed.Bvars.t
              val lc_closed : term -> bool
              val lc_repr : lc_term -> term
              val lc_iter : (term -> unit) -> term -> unit
              val f_map :
                ?pool:pool ->
                ?forall:bool ->
                ?exists:bool ->
                ?lambda:bool -> (term -> term) -> term -> term
              val f_iter :
                ?pool:pool ->
                ?forall:bool ->
                ?exists:bool ->
                ?lambda:bool -> (term -> unit) -> term -> unit
              val typeof :
                ?field:(Field.t -> tau) ->
                ?record:(Field.t -> tau) ->
                ?call:(Fun.t -> tau option list -> tau) -> term -> tau
              val set_builtin :
                ?force:bool -> Fun.t -> (term list -> term) -> unit
              val set_builtin' :
                ?force:bool ->
                Fun.t -> (term list -> tau option -> term) -> unit
              val set_builtin_map :
                ?force:bool -> Fun.t -> (term list -> term list) -> unit
              val set_builtin_get :
                ?force:bool ->
                Fun.t -> (term list -> tau option -> term -> term) -> unit
              val set_builtin_eq :
                ?force:bool -> Fun.t -> (term -> term -> term) -> unit
              val set_builtin_leq :
                ?force:bool -> Fun.t -> (term -> term -> term) -> unit
              val consequence : term -> term -> term
              val literal : term -> bool * term
              val affine : term -> term Qed.Logic.affine
              val record_with : record -> (term * record) option
              type t = term
              val id : t -> int
              val hash : t -> int
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val pretty : Format.formatter -> t -> unit
              val weigth : t -> int
              val is_closed : t -> bool
              val is_simple : t -> bool
              val is_atomic : t -> bool
              val is_primitive : t -> bool
              val is_neutral : Fun.t -> t -> bool
              val is_absorbant : Fun.t -> t -> bool
              val size : t -> int
              val basename : t -> string
              val debug : Format.formatter -> t -> unit
              val pp_id : Format.formatter -> t -> unit
              val pp_rid : Format.formatter -> t -> unit
              val pp_repr : Format.formatter -> repr -> unit
              val is_subterm : term -> term -> bool
              val shared :
                ?shared:(term -> bool) ->
                ?shareable:(term -> bool) ->
                ?subterms:((term -> unit) -> term -> unit) ->
                term list -> term list
              type marks
              val marks :
                ?shared:(term -> bool) ->
                ?shareable:(term -> bool) ->
                ?subterms:((term -> unit) -> term -> unit) -> unit -> marks
              val mark : marks -> term -> unit
              val share : marks -> term -> unit
              val defs : marks -> term list
            end
          type var = Wp.Lang.F.QED.var
          type tau = Wp.Lang.F.QED.tau
          type pool = Wp.Lang.F.QED.pool
          module Tau = QED.Tau
          module Var = QED.Var
          module Vars :
            sig
              type elt = var
              type t
              val empty : t
              val is_empty : t -> bool
              val mem : elt -> t -> bool
              val find : elt -> t -> elt
              val add : elt -> t -> t
              val singleton : elt -> t
              val remove : elt -> t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val compare : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val for_all : (elt -> bool) -> t -> bool
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val partition : (elt -> bool) -> t -> t * t
              val cardinal : t -> int
              val elements : t -> elt list
              val map : (elt -> elt) -> t -> t
              val mapf : (elt -> elt option) -> t -> t
              val intersect : t -> t -> bool
            end
          module Vmap :
            sig
              type key = var
              type 'a t
              val is_empty : 'a t -> bool
              val empty : 'a t
              val add : key -> '-> 'a t -> 'a t
              val mem : key -> 'a t -> bool
              val find : key -> 'a t -> 'a
              val remove : key -> 'a t -> 'a t
              val compare : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val iter : (key -> '-> unit) -> 'a t -> unit
              val map : (key -> '-> 'b) -> 'a t -> 'b t
              val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
              val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
              val filter : (key -> '-> bool) -> 'a t -> 'a t
              val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
              val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
              val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val interf :
                (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
              val interq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val diffq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val merge :
                (key -> 'a option -> 'b option -> 'c option) ->
                'a t -> 'b t -> 'c t
              val iter2 :
                (key -> 'a option -> 'b option -> unit) ->
                'a t -> 'b t -> unit
              val subset : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
              val insert :
                (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
              val change :
                (key -> '-> 'a option -> 'a option) ->
                key -> '-> 'a t -> 'a t
            end
          val pool : ?copy:Wp.Lang.F.pool -> unit -> Wp.Lang.F.pool
          val fresh :
            Wp.Lang.F.pool ->
            ?basename:string -> Wp.Lang.F.tau -> Wp.Lang.F.var
          val alpha : Wp.Lang.F.pool -> Wp.Lang.F.var -> Wp.Lang.F.var
          val add_var : Wp.Lang.F.pool -> Wp.Lang.F.var -> unit
          val add_vars : Wp.Lang.F.pool -> Wp.Lang.F.Vars.t -> unit
          val tau_of_var : Wp.Lang.F.var -> Wp.Lang.F.tau
          type term = Wp.Lang.F.QED.term
          type record = (Wp.Lang.field * Wp.Lang.F.term) list
          val hash : Wp.Lang.F.term -> int
          val equal : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
          val compare : Wp.Lang.F.term -> Wp.Lang.F.term -> int
          module Tset :
            sig
              type elt = term
              type t
              val empty : t
              val is_empty : t -> bool
              val mem : elt -> t -> bool
              val find : elt -> t -> elt
              val add : elt -> t -> t
              val singleton : elt -> t
              val remove : elt -> t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val compare : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val for_all : (elt -> bool) -> t -> bool
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val partition : (elt -> bool) -> t -> t * t
              val cardinal : t -> int
              val elements : t -> elt list
              val map : (elt -> elt) -> t -> t
              val mapf : (elt -> elt option) -> t -> t
              val intersect : t -> t -> bool
            end
          module Tmap :
            sig
              type key = term
              type 'a t
              val is_empty : 'a t -> bool
              val empty : 'a t
              val add : key -> '-> 'a t -> 'a t
              val mem : key -> 'a t -> bool
              val find : key -> 'a t -> 'a
              val remove : key -> 'a t -> 'a t
              val compare : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val iter : (key -> '-> unit) -> 'a t -> unit
              val map : (key -> '-> 'b) -> 'a t -> 'b t
              val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
              val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
              val filter : (key -> '-> bool) -> 'a t -> 'a t
              val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
              val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
              val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val interf :
                (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
              val interq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val diffq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val merge :
                (key -> 'a option -> 'b option -> 'c option) ->
                'a t -> 'b t -> 'c t
              val iter2 :
                (key -> 'a option -> 'b option -> unit) ->
                'a t -> 'b t -> unit
              val subset : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
              val insert :
                (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
              val change :
                (key -> '-> 'a option -> 'a option) ->
                key -> '-> 'a t -> 'a t
            end
          type unop = Wp.Lang.F.term -> Wp.Lang.F.term
          type binop = Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_zero : Wp.Lang.F.term
          val e_one : Wp.Lang.F.term
          val e_minus_one : Wp.Lang.F.term
          val e_minus_one_real : Wp.Lang.F.term
          val e_one_real : Wp.Lang.F.term
          val e_zero_real : Wp.Lang.F.term
          val constant : Wp.Lang.F.term -> Wp.Lang.F.term
          val e_fact : int -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_int64 : int64 -> Wp.Lang.F.term
          val e_bigint : Integer.t -> Wp.Lang.F.term
          val e_float : float -> Wp.Lang.F.term
          val e_setfield :
            Wp.Lang.F.term ->
            Wp.Lang.field -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_range : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val is_zero : Wp.Lang.F.term -> bool
          val e_true : Wp.Lang.F.term
          val e_false : Wp.Lang.F.term
          val e_bool : bool -> Wp.Lang.F.term
          val e_literal : bool -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_int : int -> Wp.Lang.F.term
          val e_zint : Z.t -> Wp.Lang.F.term
          val e_real : Q.t -> Wp.Lang.F.term
          val e_var : Wp.Lang.F.var -> Wp.Lang.F.term
          val e_opp : Wp.Lang.F.term -> Wp.Lang.F.term
          val e_times : Z.t -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_sum : Wp.Lang.F.term list -> Wp.Lang.F.term
          val e_prod : Wp.Lang.F.term list -> Wp.Lang.F.term
          val e_add : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_sub : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_mul : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_div : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_mod : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_eq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_neq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_leq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_lt : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_imply :
            Wp.Lang.F.term list -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_equiv : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_and : Wp.Lang.F.term list -> Wp.Lang.F.term
          val e_or : Wp.Lang.F.term list -> Wp.Lang.F.term
          val e_not : Wp.Lang.F.term -> Wp.Lang.F.term
          val e_if :
            Wp.Lang.F.term ->
            Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_const : Wp.Lang.F.tau -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_get : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_set :
            Wp.Lang.F.term ->
            Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_getfield :
            Wp.Lang.F.term -> Wp.Lang.Field.t -> Wp.Lang.F.term
          val e_record : Wp.Lang.F.record -> Wp.Lang.F.term
          val e_fun :
            ?result:Wp.Lang.F.tau ->
            Wp.Lang.Fun.t -> Wp.Lang.F.term list -> Wp.Lang.F.term
          val e_bind :
            Qed.Logic.binder ->
            Wp.Lang.F.var -> Wp.Lang.F.term -> Wp.Lang.F.term
          val e_open :
            pool:Wp.Lang.F.pool ->
            ?forall:bool ->
            ?exists:bool ->
            ?lambda:bool ->
            Wp.Lang.F.term ->
            (Qed.Logic.binder * Wp.Lang.F.var) list * Wp.Lang.F.term
          val e_close :
            (Qed.Logic.binder * Wp.Lang.F.var) list ->
            Wp.Lang.F.term -> Wp.Lang.F.term
          type pred
          type cmp = Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
          type operator = Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          module Pmap :
            sig
              type key = pred
              type 'a t
              val is_empty : 'a t -> bool
              val empty : 'a t
              val add : key -> '-> 'a t -> 'a t
              val mem : key -> 'a t -> bool
              val find : key -> 'a t -> 'a
              val remove : key -> 'a t -> 'a t
              val compare : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val iter : (key -> '-> unit) -> 'a t -> unit
              val map : (key -> '-> 'b) -> 'a t -> 'b t
              val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
              val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
              val filter : (key -> '-> bool) -> 'a t -> 'a t
              val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
              val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
              val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val interf :
                (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
              val interq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val diffq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val merge :
                (key -> 'a option -> 'b option -> 'c option) ->
                'a t -> 'b t -> 'c t
              val iter2 :
                (key -> 'a option -> 'b option -> unit) ->
                'a t -> 'b t -> unit
              val subset : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
              val insert :
                (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
              val change :
                (key -> '-> 'a option -> 'a option) ->
                key -> '-> 'a t -> 'a t
            end
          module Pset :
            sig
              type elt = pred
              type t
              val empty : t
              val is_empty : t -> bool
              val mem : elt -> t -> bool
              val find : elt -> t -> elt
              val add : elt -> t -> t
              val singleton : elt -> t
              val remove : elt -> t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val compare : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val for_all : (elt -> bool) -> t -> bool
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val partition : (elt -> bool) -> t -> t * t
              val cardinal : t -> int
              val elements : t -> elt list
              val map : (elt -> elt) -> t -> t
              val mapf : (elt -> elt option) -> t -> t
              val intersect : t -> t -> bool
            end
          val p_true : Wp.Lang.F.pred
          val p_false : Wp.Lang.F.pred
          val p_equal : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
          val p_equals :
            (Wp.Lang.F.term * Wp.Lang.F.term) list -> Wp.Lang.F.pred list
          val p_neq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
          val p_leq : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
          val p_lt : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.pred
          val p_positive : Wp.Lang.F.term -> Wp.Lang.F.pred
          val is_ptrue : Wp.Lang.F.pred -> Qed.Logic.maybe
          val is_pfalse : Wp.Lang.F.pred -> Qed.Logic.maybe
          val is_equal : Wp.Lang.F.term -> Wp.Lang.F.term -> Qed.Logic.maybe
          val eqp : Wp.Lang.F.pred -> Wp.Lang.F.pred -> bool
          val comparep : Wp.Lang.F.pred -> Wp.Lang.F.pred -> int
          val p_bool : Wp.Lang.F.term -> Wp.Lang.F.pred
          val e_prop : Wp.Lang.F.pred -> Wp.Lang.F.term
          val p_bools : Wp.Lang.F.term list -> Wp.Lang.F.pred list
          val e_props : Wp.Lang.F.pred list -> Wp.Lang.F.term list
          val e_lift :
            (Wp.Lang.F.term -> Wp.Lang.F.term) ->
            Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_lift :
            (Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
            Wp.Lang.F.term -> Wp.Lang.F.term
          val p_not : Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_and : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_or : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_imply : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_equiv : Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_hyps :
            Wp.Lang.F.pred list -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_if :
            Wp.Lang.F.pred ->
            Wp.Lang.F.pred -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_conj : Wp.Lang.F.pred list -> Wp.Lang.F.pred
          val p_disj : Wp.Lang.F.pred list -> Wp.Lang.F.pred
          val p_any : ('-> Wp.Lang.F.pred) -> 'a list -> Wp.Lang.F.pred
          val p_all : ('-> Wp.Lang.F.pred) -> 'a list -> Wp.Lang.F.pred
          val p_call : Wp.Lang.lfun -> Wp.Lang.F.term list -> Wp.Lang.F.pred
          val p_forall :
            Wp.Lang.F.var list -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_exists :
            Wp.Lang.F.var list -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_bind :
            Qed.Logic.binder ->
            Wp.Lang.F.var -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          type sigma
          module Subst :
            sig
              val copy : Wp.Lang.F.sigma -> Wp.Lang.F.sigma
              val find : Wp.Lang.F.sigma -> Wp.Lang.F.term -> Wp.Lang.F.term
              val add :
                Wp.Lang.F.sigma -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
              val add_fun :
                Wp.Lang.F.sigma -> (Wp.Lang.F.term -> Wp.Lang.F.term) -> unit
              val add_filter :
                Wp.Lang.F.sigma -> (Wp.Lang.F.term -> bool) -> unit
            end
          val e_subst : Wp.Lang.F.sigma -> Wp.Lang.F.term -> Wp.Lang.F.term
          val p_subst : Wp.Lang.F.sigma -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val p_subst_var :
            Wp.Lang.F.var ->
            Wp.Lang.F.term -> Wp.Lang.F.pred -> Wp.Lang.F.pred
          val e_vars : Wp.Lang.F.term -> Wp.Lang.F.var list
          val p_vars : Wp.Lang.F.pred -> Wp.Lang.F.var list
          val p_close : Wp.Lang.F.pred -> Wp.Lang.F.pred
          val pp_tau : Stdlib.Format.formatter -> Wp.Lang.F.tau -> unit
          val pp_var : Stdlib.Format.formatter -> Wp.Lang.F.var -> unit
          val pp_vars : Stdlib.Format.formatter -> Wp.Lang.F.Vars.t -> unit
          val pp_term : Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
          val pp_pred : Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
          val debugp : Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
          type env
          val context_pp : Wp.Lang.F.env Wp.Context.value
          type marks = Wp.Lang.F.QED.marks
          val env : Wp.Lang.F.Vars.t -> Wp.Lang.F.env
          val marker : Wp.Lang.F.env -> Wp.Lang.F.marks
          val mark_e : Wp.Lang.F.marks -> Wp.Lang.F.term -> unit
          val mark_p : Wp.Lang.F.marks -> Wp.Lang.F.pred -> unit
          val defs : Wp.Lang.F.marks -> Wp.Lang.F.term list
          val define :
            (Wp.Lang.F.env -> string -> Wp.Lang.F.term -> unit) ->
            Wp.Lang.F.env -> Wp.Lang.F.marks -> Wp.Lang.F.env
          val pp_eterm :
            Wp.Lang.F.env ->
            Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
          val pp_epred :
            Wp.Lang.F.env ->
            Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
          val p_expr :
            Wp.Lang.F.pred -> Wp.Lang.F.pred Wp.Lang.F.QED.expression
          val e_expr :
            Wp.Lang.F.pred -> Wp.Lang.F.term Wp.Lang.F.QED.expression
          val lc_closed : Wp.Lang.F.term -> bool
          val lc_iter : (Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> unit
          val decide : Wp.Lang.F.term -> bool
          val basename : Wp.Lang.F.term -> string
          val is_true : Wp.Lang.F.term -> Qed.Logic.maybe
          val is_false : Wp.Lang.F.term -> Qed.Logic.maybe
          val is_prop : Wp.Lang.F.term -> bool
          val is_int : Wp.Lang.F.term -> bool
          val is_real : Wp.Lang.F.term -> bool
          val is_arith : Wp.Lang.F.term -> bool
          val is_closed : Wp.Lang.F.term -> bool
          val is_simple : Wp.Lang.F.term -> bool
          val is_atomic : Wp.Lang.F.term -> bool
          val is_primitive : Wp.Lang.F.term -> bool
          val is_neutral : Wp.Lang.Fun.t -> Wp.Lang.F.term -> bool
          val is_absorbant : Wp.Lang.Fun.t -> Wp.Lang.F.term -> bool
          val record_with :
            Wp.Lang.F.record -> (Wp.Lang.F.term * Wp.Lang.F.record) option
          val are_equal : Wp.Lang.F.term -> Wp.Lang.F.term -> Qed.Logic.maybe
          val eval_eq : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
          val eval_neq : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
          val eval_lt : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
          val eval_leq : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
          val repr : Wp.Lang.F.term -> Wp.Lang.F.QED.repr
          val sort : Wp.Lang.F.term -> Qed.Logic.sort
          val vars : Wp.Lang.F.term -> Wp.Lang.F.Vars.t
          val varsp : Wp.Lang.F.pred -> Wp.Lang.F.Vars.t
          val occurs : Wp.Lang.F.var -> Wp.Lang.F.term -> bool
          val occursp : Wp.Lang.F.var -> Wp.Lang.F.pred -> bool
          val intersect : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
          val intersectp : Wp.Lang.F.pred -> Wp.Lang.F.pred -> bool
          val is_subterm : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
          val typeof :
            ?field:(Wp.Lang.Field.t -> Wp.Lang.F.tau) ->
            ?record:(Wp.Lang.Field.t -> Wp.Lang.F.tau) ->
            ?call:(Wp.Lang.Fun.t ->
                   Wp.Lang.F.tau option list -> Wp.Lang.F.tau) ->
            Wp.Lang.F.term -> Wp.Lang.F.tau
          val set_builtin :
            Wp.Lang.lfun -> (Wp.Lang.F.term list -> Wp.Lang.F.term) -> unit
          val set_builtin_get :
            Wp.Lang.lfun ->
            (Wp.Lang.F.term list ->
             Wp.Lang.F.tau option -> Wp.Lang.F.term -> Wp.Lang.F.term) ->
            unit
          val set_builtin_1 : Wp.Lang.lfun -> Wp.Lang.F.unop -> unit
          val set_builtin_2 : Wp.Lang.lfun -> Wp.Lang.F.binop -> unit
          val set_builtin_2' :
            Wp.Lang.lfun ->
            (Wp.Lang.F.term ->
             Wp.Lang.F.term -> Wp.Lang.F.tau option -> Wp.Lang.F.term) ->
            unit
          val set_builtin_eq : Wp.Lang.lfun -> Wp.Lang.F.binop -> unit
          val set_builtin_leq : Wp.Lang.lfun -> Wp.Lang.F.binop -> unit
          val set_builtin_eqp : Wp.Lang.lfun -> Wp.Lang.F.cmp -> unit
          val release : unit -> unit
        end
      module N :
        sig
          val ( + ) : Wp.Lang.F.binop
          val ( - ) : Wp.Lang.F.binop
          val ( ~- ) : Wp.Lang.F.unop
          val ( * ) : Wp.Lang.F.binop
          val ( / ) : Wp.Lang.F.binop
          val ( mod ) : Wp.Lang.F.binop
          val ( = ) : Wp.Lang.F.cmp
          val ( < ) : Wp.Lang.F.cmp
          val ( > ) : Wp.Lang.F.cmp
          val ( <= ) : Wp.Lang.F.cmp
          val ( >= ) : Wp.Lang.F.cmp
          val ( <> ) : Wp.Lang.F.cmp
          val ( ==> ) : Wp.Lang.F.operator
          val ( && ) : Wp.Lang.F.operator
          val ( || ) : Wp.Lang.F.operator
          val not : Wp.Lang.F.pred -> Wp.Lang.F.pred
          val ( $ ) :
            ?result:Wp.Lang.tau ->
            Wp.Lang.lfun -> Wp.Lang.F.term list -> Wp.Lang.F.term
          val ( $$ ) : Wp.Lang.lfun -> Wp.Lang.F.term list -> Wp.Lang.F.pred
        end
      type gamma
      val new_pool :
        ?copy:Wp.Lang.F.pool ->
        ?vars:Wp.Lang.F.Vars.t -> unit -> Wp.Lang.F.pool
      val new_gamma : ?copy:Wp.Lang.gamma -> unit -> Wp.Lang.gamma
      val local :
        ?pool:Wp.Lang.F.pool ->
        ?vars:Wp.Lang.F.Vars.t ->
        ?gamma:Wp.Lang.gamma -> ('-> 'b) -> '-> 'b
      val freshvar : ?basename:string -> Wp.Lang.F.tau -> Wp.Lang.F.var
      val freshen : Wp.Lang.F.var -> Wp.Lang.F.var
      val assume : Wp.Lang.F.pred -> unit
      val without_assume : ('-> 'b) -> '-> 'b
      val hypotheses : Wp.Lang.gamma -> Wp.Lang.F.pred list
      val get_pool : unit -> Wp.Lang.F.pool
      val get_gamma : unit -> Wp.Lang.gamma
      val has_gamma : unit -> bool
      val get_hypotheses : unit -> Wp.Lang.F.pred list
      val filter_hypotheses : Wp.Lang.F.var list -> Wp.Lang.F.pred list
      val sigma : unit -> Wp.Lang.F.sigma
      val alpha : unit -> Wp.Lang.F.sigma
      val subst :
        Wp.Lang.F.var list -> Wp.Lang.F.term list -> Wp.Lang.F.sigma
      val e_subst :
        (Wp.Lang.F.term -> Wp.Lang.F.term) ->
        Wp.Lang.F.term -> Wp.Lang.F.term
      val p_subst :
        (Wp.Lang.F.term -> Wp.Lang.F.term) ->
        Wp.Lang.F.pred -> Wp.Lang.F.pred
      exception Contradiction
      val is_literal : Wp.Lang.F.term -> bool
      val iter_consequence_literals :
        (Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> unit
      class type simplifier =
        object
          method assume : Wp.Lang.F.pred -> unit
          method copy : Wp.Lang.simplifier
          method equivalent_branch : Wp.Lang.F.pred -> Wp.Lang.F.pred
          method equivalent_exp : Wp.Lang.F.term -> Wp.Lang.F.term
          method fixpoint : unit
          method infer : Wp.Lang.F.pred list
          method name : string
          method stronger_goal : Wp.Lang.F.pred -> Wp.Lang.F.pred
          method target : Wp.Lang.F.pred -> unit
          method weaker_hyp : Wp.Lang.F.pred -> Wp.Lang.F.pred
        end
      module For_export :
        sig
          type specific_equality = {
            for_tau : Wp.Lang.F.tau -> bool;
            mk_new_eq : Wp.Lang.F.binop;
          }
          val rebuild :
            ?cache:Wp.Lang.F.term Wp.Lang.F.Tmap.t ->
            Wp.Lang.F.term ->
            Wp.Lang.F.term * Wp.Lang.F.term Wp.Lang.F.Tmap.t
          val set_builtin :
            Wp.Lang.Fun.t -> (Wp.Lang.F.term list -> Wp.Lang.F.term) -> unit
          val set_builtin' :
            Wp.Lang.Fun.t ->
            (Wp.Lang.F.term list -> Wp.Lang.F.tau option -> Wp.Lang.F.term) ->
            unit
          val set_builtin_eq :
            Wp.Lang.Fun.t ->
            (Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term) -> unit
          val set_builtin_leq :
            Wp.Lang.Fun.t ->
            (Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term) -> unit
          val in_state : ('-> 'b) -> '-> 'b
        end
    end
  module Repr :
    sig
      type tau = Wp.Lang.F.tau
      type var = Wp.Lang.F.var
      type field = Wp.Lang.field
      type lfun = Wp.Lang.lfun
      type term = Wp.Lang.F.term
      type pred = Wp.Lang.F.pred
      type repr =
          True
        | False
        | And of Wp.Repr.term list
        | Or of Wp.Repr.term list
        | Not of Wp.Repr.term
        | Imply of Wp.Repr.term list * Wp.Repr.term
        | If of Wp.Repr.term * Wp.Repr.term * Wp.Repr.term
        | Var of Wp.Repr.var
        | Int of Z.t
        | Real of Q.t
        | Add of Wp.Repr.term list
        | Mul of Wp.Repr.term list
        | Div of Wp.Repr.term * Wp.Repr.term
        | Mod of Wp.Repr.term * Wp.Repr.term
        | Eq of Wp.Repr.term * Wp.Repr.term
        | Neq of Wp.Repr.term * Wp.Repr.term
        | Lt of Wp.Repr.term * Wp.Repr.term
        | Leq of Wp.Repr.term * Wp.Repr.term
        | Times of Z.t * Wp.Repr.term
        | Call of Wp.Repr.lfun * Wp.Repr.term list
        | Field of Wp.Repr.term * Wp.Repr.field
        | Record of (Wp.Repr.field * Wp.Repr.term) list
        | Cst of Wp.Repr.tau * Wp.Repr.term
        | Get of Wp.Repr.term * Wp.Repr.term
        | Set of Wp.Repr.term * Wp.Repr.term * Wp.Repr.term
        | HigherOrder
      val term : Wp.Repr.term -> Wp.Repr.repr
      val pred : Wp.Repr.pred -> Wp.Repr.repr
      val lfun : Wp.Repr.lfun -> string
      val field : Wp.Repr.field -> string
    end
  module Passive :
    sig
      type t
      val empty : Wp.Passive.t
      val is_empty : Wp.Passive.t -> bool
      val union : Wp.Passive.t -> Wp.Passive.t -> Wp.Passive.t
      val bind :
        fresh:Wp.Lang.F.var ->
        bound:Wp.Lang.F.var -> Wp.Passive.t -> Wp.Passive.t
      val join :
        Wp.Lang.F.var -> Wp.Lang.F.var -> Wp.Passive.t -> Wp.Passive.t
      val conditions :
        Wp.Passive.t -> (Wp.Lang.F.var -> bool) -> Wp.Lang.F.pred list
      val apply : Wp.Passive.t -> Wp.Lang.F.pred -> Wp.Lang.F.pred
      type binding =
          Bind of Wp.Lang.F.var * Wp.Lang.F.var
        | Join of Wp.Lang.F.var * Wp.Lang.F.var
      val iter : (Wp.Passive.binding -> unit) -> Wp.Passive.t -> unit
      val pretty : Stdlib.Format.formatter -> Wp.Passive.t -> unit
    end
  module Splitter :
    sig
      type tag =
          THEN of Cil_types.stmt
        | ELSE of Cil_types.stmt
        | CALL of Cil_types.stmt * Cil_types.kernel_function
        | CASE of Cil_types.stmt * int64 list
        | DEFAULT of Cil_types.stmt
        | ASSERT of Cil_types.identified_predicate * int * int
      val loc : Wp.Splitter.tag -> Cil_types.location
      val pretty : Stdlib.Format.formatter -> Wp.Splitter.tag -> unit
      val if_then : Cil_types.stmt -> Wp.Splitter.tag
      val if_else : Cil_types.stmt -> Wp.Splitter.tag
      val switch_cases : Cil_types.stmt -> int64 list -> Wp.Splitter.tag
      val switch_default : Cil_types.stmt -> Wp.Splitter.tag
      val cases :
        Cil_types.identified_predicate ->
        (Wp.Splitter.tag * Cil_types.predicate) list option
      val call :
        Cil_types.stmt -> Cil_types.kernel_function -> Wp.Splitter.tag
      type 'a t
      val empty : 'Wp.Splitter.t
      val singleton : '-> 'Wp.Splitter.t
      val group :
        Wp.Splitter.tag ->
        ('a list -> 'a) -> 'Wp.Splitter.t -> 'Wp.Splitter.t
      val union :
        ('-> '-> 'a) ->
        'Wp.Splitter.t -> 'Wp.Splitter.t -> 'Wp.Splitter.t
      val merge :
        left:('-> 'c) ->
        both:('-> '-> 'c) ->
        right:('-> 'c) ->
        'Wp.Splitter.t -> 'Wp.Splitter.t -> 'Wp.Splitter.t
      val merge_all :
        ('a list -> 'a) -> 'Wp.Splitter.t list -> 'Wp.Splitter.t
      val unmark : ('a list -> 'a) -> 'Wp.Splitter.t -> 'Wp.Splitter.t
      val length : 'Wp.Splitter.t -> int
      val map : ('-> 'b) -> 'Wp.Splitter.t -> 'Wp.Splitter.t
      val iter :
        (Wp.Splitter.tag list -> '-> unit) -> 'Wp.Splitter.t -> unit
      val fold :
        (Wp.Splitter.tag list -> '-> '-> 'b) ->
        'Wp.Splitter.t -> '-> 'b
      val exists : ('-> bool) -> 'Wp.Splitter.t -> bool
      val for_all : ('-> bool) -> 'Wp.Splitter.t -> bool
      val filter : ('-> bool) -> 'Wp.Splitter.t -> 'Wp.Splitter.t
    end
  module LogicBuiltins :
    sig
      type category = Wp.Lang.lfun Qed.Logic.category
      type kind = Z | R | I of Wp.Ctypes.c_int | F of Wp.Ctypes.c_float | A
      val kind_of_tau : Wp.Lang.tau -> Wp.LogicBuiltins.kind
      val add_builtin :
        string -> Wp.LogicBuiltins.kind list -> Wp.Lang.lfun -> unit
      type driver
      val driver : Wp.LogicBuiltins.driver Wp.Context.value
      val new_driver :
        id:string ->
        ?base:Wp.LogicBuiltins.driver ->
        ?descr:string ->
        ?includes:string list ->
        ?configure:(unit -> unit) -> unit -> Wp.LogicBuiltins.driver
      val id : Wp.LogicBuiltins.driver -> string
      val descr : Wp.LogicBuiltins.driver -> string
      val is_default : Wp.LogicBuiltins.driver -> bool
      val compare : Wp.LogicBuiltins.driver -> Wp.LogicBuiltins.driver -> int
      val find_lib : string -> string
      val dependencies : string -> string list
      val add_library : string -> string list -> unit
      val add_alias :
        source:Filepath.position ->
        string -> Wp.LogicBuiltins.kind list -> alias:string -> unit -> unit
      val add_type :
        ?source:Filepath.position ->
        string -> library:string -> ?link:string -> unit -> unit
      val add_ctor :
        source:Filepath.position ->
        string ->
        Wp.LogicBuiltins.kind list ->
        library:string -> link:Qed.Engine.link -> unit -> unit
      val add_logic :
        source:Filepath.position ->
        Wp.LogicBuiltins.kind ->
        string ->
        Wp.LogicBuiltins.kind list ->
        library:string ->
        ?category:Wp.LogicBuiltins.category ->
        link:Qed.Engine.link -> unit -> unit
      val add_predicate :
        source:Filepath.position ->
        string ->
        Wp.LogicBuiltins.kind list ->
        library:string -> link:string -> unit -> unit
      val add_option :
        driver_dir:string ->
        string -> string -> library:string -> string -> unit
      val set_option :
        driver_dir:string ->
        string -> string -> library:string -> string -> unit
      type doption
      type sanitizer = driver_dir:string -> string -> string
      val create_option :
        sanitizer:Wp.LogicBuiltins.sanitizer ->
        string -> string -> Wp.LogicBuiltins.doption
      val get_option :
        Wp.LogicBuiltins.doption -> library:string -> string list
      type builtin =
          ACSLDEF
        | LFUN of Wp.Lang.lfun
        | HACK of (Wp.Lang.F.term list -> Wp.Lang.F.term)
      val logic : Cil_types.logic_info -> Wp.LogicBuiltins.builtin
      val ctor : Cil_types.logic_ctor_info -> Wp.LogicBuiltins.builtin
      val constant : string -> Wp.LogicBuiltins.builtin
      val lookup :
        string -> Wp.LogicBuiltins.kind list -> Wp.LogicBuiltins.builtin
      val hack : string -> (Wp.Lang.F.term list -> Wp.Lang.F.term) -> unit
      val hack_type : string -> (Wp.Lang.F.tau list -> Wp.Lang.F.tau) -> unit
      val dump : unit -> unit
    end
  module Definitions :
    sig
      type cluster
      val dummy : unit -> Wp.Definitions.cluster
      val cluster :
        id:string ->
        ?title:string ->
        ?position:Filepath.position -> unit -> Wp.Definitions.cluster
      val axiomatic : Wp.LogicUsage.axiomatic -> Wp.Definitions.cluster
      val section : Wp.LogicUsage.logic_section -> Wp.Definitions.cluster
      val compinfo : Cil_types.compinfo -> Wp.Definitions.cluster
      val matrix : unit -> Wp.Definitions.cluster
      val cluster_id : Wp.Definitions.cluster -> string
      val cluster_title : Wp.Definitions.cluster -> string
      val cluster_position :
        Wp.Definitions.cluster -> Filepath.position option
      val cluster_age : Wp.Definitions.cluster -> int
      val cluster_compare :
        Wp.Definitions.cluster -> Wp.Definitions.cluster -> int
      val pp_cluster :
        Stdlib.Format.formatter -> Wp.Definitions.cluster -> unit
      val iter : (Wp.Definitions.cluster -> unit) -> unit
      type trigger = (Wp.Lang.F.var, Wp.Lang.lfun) Qed.Engine.ftrigger
      type typedef =
          (Wp.Lang.F.tau, Wp.Lang.field, Wp.Lang.lfun) Qed.Engine.ftypedef
      type dlemma = {
        l_name : string;
        l_cluster : Wp.Definitions.cluster;
        l_kind : Cil_types.predicate_kind;
        l_types : int;
        l_forall : Wp.Lang.F.var list;
        l_triggers : Wp.Definitions.trigger list list;
        l_lemma : Wp.Lang.F.pred;
      }
      type definition =
          Logic of Wp.Lang.F.tau
        | Function of Wp.Lang.F.tau * Wp.Definitions.recursion *
            Wp.Lang.F.term
        | Predicate of Wp.Definitions.recursion * Wp.Lang.F.pred
        | Inductive of Wp.Definitions.dlemma list
      and recursion = Def | Rec
      type dfun = {
        d_lfun : Wp.Lang.lfun;
        d_cluster : Wp.Definitions.cluster;
        d_types : int;
        d_params : Wp.Lang.F.var list;
        d_definition : Wp.Definitions.definition;
      }
      module Trigger :
        sig
          val of_term : Wp.Lang.F.term -> Wp.Definitions.trigger
          val of_pred : Wp.Lang.F.pred -> Wp.Definitions.trigger
          val vars : Wp.Definitions.trigger -> Wp.Lang.F.Vars.t
        end
      val find_symbol : Wp.Lang.lfun -> Wp.Definitions.dfun
      val define_symbol : Wp.Definitions.dfun -> unit
      val update_symbol : Wp.Definitions.dfun -> unit
      val find_name : string -> Wp.Definitions.dlemma
      val find_lemma : Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma
      val compile_lemma :
        (Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma) ->
        Wp.LogicUsage.logic_lemma -> unit
      val define_lemma : Wp.Definitions.dlemma -> unit
      val define_type :
        Wp.Definitions.cluster -> Cil_types.logic_type_info -> unit
      val call_fun :
        result:Wp.Lang.F.tau ->
        Wp.Lang.lfun ->
        (Wp.Lang.lfun -> Wp.Definitions.dfun) ->
        Wp.Lang.F.term list -> Wp.Lang.F.term
      val call_pred :
        Wp.Lang.lfun ->
        (Wp.Lang.lfun -> Wp.Definitions.dfun) ->
        Wp.Lang.F.term list -> Wp.Lang.F.pred
      type axioms = Wp.Definitions.cluster * Wp.LogicUsage.logic_lemma list
      class virtual visitor :
        Wp.Definitions.cluster ->
        object
          method do_local : Wp.Definitions.cluster -> bool
          method virtual on_cluster : Wp.Definitions.cluster -> unit
          method virtual on_comp :
            Cil_types.compinfo ->
            (Wp.Lang.field * Wp.Lang.F.tau) list option -> unit
          method virtual on_dfun : Wp.Definitions.dfun -> unit
          method virtual on_dlemma : Wp.Definitions.dlemma -> unit
          method virtual on_icomp :
            Cil_types.compinfo ->
            (Wp.Lang.field * Wp.Lang.F.tau) list option -> unit
          method virtual on_library : string -> unit
          method virtual on_type :
            Cil_types.logic_type_info -> Wp.Definitions.typedef -> unit
          method virtual section : string -> unit
          method set_local : Wp.Definitions.cluster -> unit
          method vadt : Wp.Lang.ADT.t -> unit
          method vcluster : Wp.Definitions.cluster -> unit
          method vcomp : Cil_types.compinfo -> unit
          method vfield : Wp.Lang.Field.t -> unit
          method vgoal :
            Wp.Definitions.axioms option -> Wp.Lang.F.pred -> unit
          method vicomp : Cil_types.compinfo -> unit
          method vlemma : Wp.LogicUsage.logic_lemma -> unit
          method vlemmas : unit
          method vlibrary : string -> unit
          method vparam : Wp.Lang.F.var -> unit
          method vpred : Wp.Lang.F.pred -> unit
          method vself : unit
          method vsymbol : Wp.Lang.lfun -> unit
          method vsymbols : unit
          method vtau : Wp.Lang.F.tau -> unit
          method vterm : Wp.Lang.F.term -> unit
          method vtype : Cil_types.logic_type_info -> unit
          method vtypes : unit
        end
    end
  module Cint :
    sig
      val of_real : Wp.Ctypes.c_int -> Wp.Lang.F.unop
      val convert : Wp.Ctypes.c_int -> Wp.Lang.F.unop
      val to_integer : Wp.Lang.F.unop
      val of_integer : Wp.Ctypes.c_int -> Wp.Lang.F.unop
      val to_cint : Wp.Lang.lfun -> Wp.Ctypes.c_int
      val is_cint : Wp.Lang.lfun -> Wp.Ctypes.c_int
      type model = Natural | Machine
      val configure : Wp.Cint.model -> Wp.WpContext.rollback
      val current : unit -> Wp.Cint.model
      val range : Wp.Ctypes.c_int -> Wp.Lang.F.term -> Wp.Lang.F.pred
      val downcast : Wp.Ctypes.c_int -> Wp.Lang.F.unop
      val iopp : Wp.Ctypes.c_int -> Wp.Lang.F.unop
      val iadd : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val isub : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val imul : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val idiv : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val imod : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val bnot : Wp.Ctypes.c_int -> Wp.Lang.F.unop
      val band : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val bxor : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val bor : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val blsl : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val blsr : Wp.Ctypes.c_int -> Wp.Lang.F.binop
      val l_not : Wp.Lang.F.unop
      val l_and : Wp.Lang.F.binop
      val l_xor : Wp.Lang.F.binop
      val l_or : Wp.Lang.F.binop
      val l_lsl : Wp.Lang.F.binop
      val l_lsr : Wp.Lang.F.binop
      val f_lnot : Wp.Lang.lfun
      val f_land : Wp.Lang.lfun
      val f_lxor : Wp.Lang.lfun
      val f_lor : Wp.Lang.lfun
      val f_lsl : Wp.Lang.lfun
      val f_lsr : Wp.Lang.lfun
      val f_bitwised : Wp.Lang.lfun list
      val f_bits : Wp.Lang.lfun list
      val bit_test : Wp.Lang.F.term -> int -> Wp.Lang.F.term
      val match_power2 : Wp.Lang.F.term -> Wp.Lang.F.term
      val match_power2_minus1 : Wp.Lang.F.term -> Wp.Lang.F.term
      val is_cint_simplifier : Wp.Lang.simplifier
      val mask_simplifier : Wp.Lang.simplifier
      val is_positive_or_null : Wp.Lang.F.term -> bool
    end
  module Cfloat :
    sig
      val f32 : Wp.Lang.adt
      val f64 : Wp.Lang.adt
      val t32 : Wp.Lang.F.tau
      val t64 : Wp.Lang.F.tau
      val fq32 : Wp.Lang.lfun
      val fq64 : Wp.Lang.lfun
      type model = Real | Float
      val configure : Wp.Cfloat.model -> Wp.WpContext.rollback
      val ftau : Wp.Ctypes.c_float -> Wp.Lang.F.tau
      val tau_of_float : Wp.Ctypes.c_float -> Wp.Lang.F.tau
      type op =
          LT
        | EQ
        | LE
        | NE
        | NEG
        | ADD
        | SUB
        | MUL
        | DIV
        | REAL
        | ROUND
        | EXACT
      val find : Wp.Lang.lfun -> Wp.Cfloat.op * Wp.Ctypes.c_float
      val code_lit :
        Wp.Ctypes.c_float -> float -> string option -> Wp.Lang.F.term
      val acsl_lit : Cil_types.logic_real -> Wp.Lang.F.term
      val float_lit : Wp.Ctypes.c_float -> Q.t -> string
      val float_of_int : Wp.Ctypes.c_float -> Wp.Lang.F.unop
      val float_of_real : Wp.Ctypes.c_float -> Wp.Lang.F.unop
      val real_of_float : Wp.Ctypes.c_float -> Wp.Lang.F.unop
      val fopp : Wp.Ctypes.c_float -> Wp.Lang.F.unop
      val fadd : Wp.Ctypes.c_float -> Wp.Lang.F.binop
      val fsub : Wp.Ctypes.c_float -> Wp.Lang.F.binop
      val fmul : Wp.Ctypes.c_float -> Wp.Lang.F.binop
      val fdiv : Wp.Ctypes.c_float -> Wp.Lang.F.binop
      val flt : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
      val fle : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
      val feq : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
      val fneq : Wp.Ctypes.c_float -> Wp.Lang.F.cmp
      val f_model : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val f_delta : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val f_epsilon : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val flt_of_real : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val real_of_flt : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val flt_add : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val flt_mul : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val flt_div : Wp.Ctypes.c_float -> Wp.Lang.lfun
      val flt_neg : Wp.Ctypes.c_float -> Wp.Lang.lfun
    end
  module Vset :
    sig
      type set = Wp.Vset.vset list
      and vset =
          Set of Wp.Lang.F.tau * Wp.Lang.F.term
        | Singleton of Wp.Lang.F.term
        | Range of Wp.Lang.F.term option * Wp.Lang.F.term option
        | Descr of Wp.Lang.F.var list * Wp.Lang.F.term * Wp.Lang.F.pred
      val tau_of_set : Wp.Lang.F.tau -> Wp.Lang.F.tau
      val vars : Wp.Vset.set -> Wp.Lang.F.Vars.t
      val occurs : Wp.Lang.F.var -> Wp.Vset.set -> bool
      val empty : Wp.Vset.set
      val singleton : Wp.Lang.F.term -> Wp.Vset.set
      val range :
        Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Vset.set
      val union : Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
      val inter : Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term
      val member : Wp.Lang.F.term -> Wp.Vset.set -> Wp.Lang.F.pred
      val in_size : Wp.Lang.F.term -> int -> Wp.Lang.F.pred
      val in_range :
        Wp.Lang.F.term ->
        Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Lang.F.pred
      val sub_range :
        Wp.Lang.F.term ->
        Wp.Lang.F.term ->
        Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Lang.F.pred
      val ordered :
        limit:bool ->
        strict:bool ->
        Wp.Lang.F.term option -> Wp.Lang.F.term option -> Wp.Lang.F.pred
      val is_empty : Wp.Vset.set -> Wp.Lang.F.pred
      val equal : Wp.Vset.set -> Wp.Vset.set -> Wp.Lang.F.pred
      val subset : Wp.Vset.set -> Wp.Vset.set -> Wp.Lang.F.pred
      val disjoint : Wp.Vset.set -> Wp.Vset.set -> Wp.Lang.F.pred
      val concretize : Wp.Vset.set -> Wp.Lang.F.term
      val bound_shift :
        Wp.Lang.F.term option -> Wp.Lang.F.term -> Wp.Lang.F.term option
      val bound_add :
        Wp.Lang.F.term option ->
        Wp.Lang.F.term option -> Wp.Lang.F.term option
      val bound_sub :
        Wp.Lang.F.term option ->
        Wp.Lang.F.term option -> Wp.Lang.F.term option
      val pp_bound : Stdlib.Format.formatter -> Wp.Lang.F.term option -> unit
      val pp_vset : Stdlib.Format.formatter -> Wp.Vset.vset -> unit
      val pretty : Stdlib.Format.formatter -> Wp.Vset.set -> unit
      val map :
        (Wp.Lang.F.term -> Wp.Lang.F.term) -> Wp.Vset.set -> Wp.Vset.set
      val map_opp : Wp.Vset.set -> Wp.Vset.set
      val lift :
        (Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term) ->
        Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
      val lift_add : Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
      val lift_sub : Wp.Vset.set -> Wp.Vset.set -> Wp.Vset.set
      val descr :
        Wp.Vset.vset -> Wp.Lang.F.var list * Wp.Lang.F.term * Wp.Lang.F.pred
    end
  module Cstring :
    sig
      type cst = C_str of string | W_str of int64 list
      val pretty : Stdlib.Format.formatter -> Wp.Cstring.cst -> unit
      val str_len : Wp.Cstring.cst -> Wp.Lang.F.term -> Wp.Lang.F.pred
      val str_val : Wp.Cstring.cst -> Wp.Lang.F.term
      val str_id : Wp.Cstring.cst -> int
      val char_at : Wp.Cstring.cst -> Wp.Lang.F.term -> Wp.Lang.F.term
      val cluster : unit -> Wp.Definitions.cluster
    end
  module Sigs :
    sig
      type 'a sequence = { pre : 'a; post : 'a; }
      type 'a binder = { bind : ''c. '-> ('-> 'c) -> '-> 'c; }
      type equation =
          Set of Wp.Lang.F.term * Wp.Lang.F.term
        | Assert of Wp.Lang.F.pred
      type acs = RW | RD | OBJ
      type 'a value = Val of Wp.Lang.F.term | Loc of 'a
      type 'a rloc =
          Rloc of Wp.Ctypes.c_object * 'a
        | Rrange of 'a * Wp.Ctypes.c_object * Wp.Lang.F.term option *
            Wp.Lang.F.term option
      type 'a sloc =
          Sloc of 'a
        | Sarray of 'a * Wp.Ctypes.c_object * int
        | Srange of 'a * Wp.Ctypes.c_object * Wp.Lang.F.term option *
            Wp.Lang.F.term option
        | Sdescr of Wp.Lang.F.var list * 'a * Wp.Lang.F.pred
      type 'a region = (Wp.Ctypes.c_object * 'Wp.Sigs.sloc) list
      type 'a logic =
          Vexp of Wp.Lang.F.term
        | Vloc of 'a
        | Vset of Wp.Vset.set
        | Lset of 'Wp.Sigs.sloc list
      type scope = Enter | Leave
      type 'a result = R_loc of '| R_var of Wp.Lang.F.var
      type polarity = [ `Negative | `NoPolarity | `Positive ]
      type frame =
          string * Wp.Definitions.trigger list * Wp.Lang.F.pred list *
          Wp.Lang.F.term * Wp.Lang.F.term
      type s_lval = Wp.Sigs.s_host * Wp.Sigs.s_offset list
      and s_host =
          Mvar of Cil_types.varinfo
        | Mmem of Wp.Lang.F.term
        | Mval of Wp.Sigs.s_lval
      and s_offset = Mfield of Cil_types.fieldinfo | Mindex of Wp.Lang.F.term
      type mval =
          Mterm
        | Maddr of Wp.Sigs.s_lval
        | Mlval of Wp.Sigs.s_lval * Wp.Lang.datakind
        | Mchunk of string * Wp.Lang.datakind
      type update = Mstore of Wp.Sigs.s_lval * Wp.Lang.F.term
      module type Chunk =
        sig
          type t
          val self : string
          val hash : Wp.Sigs.Chunk.t -> int
          val equal : Wp.Sigs.Chunk.t -> Wp.Sigs.Chunk.t -> bool
          val compare : Wp.Sigs.Chunk.t -> Wp.Sigs.Chunk.t -> int
          val pretty : Stdlib.Format.formatter -> Wp.Sigs.Chunk.t -> unit
          val tau_of_chunk : Wp.Sigs.Chunk.t -> Wp.Lang.F.tau
          val basename_of_chunk : Wp.Sigs.Chunk.t -> string
          val is_framed : Wp.Sigs.Chunk.t -> bool
        end
      module type Sigma =
        sig
          type chunk
          module Chunk :
            sig
              type t = chunk
              type set
              type 'a map
              val hash : t -> int
              val equal : t -> t -> bool
              val compare : t -> t -> int
              module Map :
                sig
                  type key = t
                  type 'a t = 'a map
                  val empty : 'a t
                  val add : key -> '-> 'a t -> 'a t
                  val mem : key -> 'a t -> bool
                  val find : key -> 'a t -> 'a
                  val findk : key -> 'a t -> key * 'a
                  val size : 'a t -> int
                  val is_empty : 'a t -> bool
                  val insert :
                    (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                  val change :
                    (key -> '-> 'a option -> 'a option) ->
                    key -> '-> 'a t -> 'a t
                  val map : ('-> 'b) -> 'a t -> 'b t
                  val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                  val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                  val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                  val fold_sorted :
                    (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                  val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val interf :
                    (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                  val interq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val diffq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val subset :
                    (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iterk :
                    (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                  val iter2 :
                    (key -> 'a option -> 'b option -> unit) ->
                    'a t -> 'b t -> unit
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  type domain = set
                  val domain : 'a t -> domain
                end
              module Set :
                sig
                  type elt = t
                  type t = set
                  val empty : t
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val elements : t -> elt list
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val filter : (elt -> bool) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val iter_sorted : (elt -> unit) -> t -> unit
                  val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val subset : t -> t -> bool
                  val intersect : t -> t -> bool
                  val of_list : elt list -> t
                  type 'a mapping = 'a map
                  val mapping : (elt -> 'a) -> t -> 'a mapping
                end
            end
          type domain = Wp.Sigs.Sigma.Chunk.Set.t
          type t
          val pretty : Stdlib.Format.formatter -> Wp.Sigs.Sigma.t -> unit
          val create : unit -> Wp.Sigs.Sigma.t
          val mem : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> bool
          val get : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> Wp.Lang.F.var
          val value :
            Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> Wp.Lang.F.term
          val copy : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t
          val join : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t -> Wp.Passive.t
          val assigned :
            pre:Wp.Sigs.Sigma.t ->
            post:Wp.Sigs.Sigma.t ->
            Wp.Sigs.Sigma.domain -> Wp.Lang.F.pred Bag.t
          val choose : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t
          val merge :
            Wp.Sigs.Sigma.t ->
            Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t * Wp.Passive.t * Wp.Passive.t
          val merge_list :
            Wp.Sigs.Sigma.t list -> Wp.Sigs.Sigma.t * Wp.Passive.t list
          val iter :
            (Wp.Sigs.Sigma.chunk -> Wp.Lang.F.var -> unit) ->
            Wp.Sigs.Sigma.t -> unit
          val iter2 :
            (Wp.Sigs.Sigma.chunk ->
             Wp.Lang.F.var option -> Wp.Lang.F.var option -> unit) ->
            Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t -> unit
          val havoc_chunk :
            Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.chunk -> Wp.Sigs.Sigma.t
          val havoc :
            Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.domain -> Wp.Sigs.Sigma.t
          val havoc_any : call:bool -> Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.t
          val remove_chunks :
            Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.domain -> Wp.Sigs.Sigma.t
          val domain : Wp.Sigs.Sigma.t -> Wp.Sigs.Sigma.domain
          val union :
            Wp.Sigs.Sigma.domain ->
            Wp.Sigs.Sigma.domain -> Wp.Sigs.Sigma.domain
          val empty : Wp.Sigs.Sigma.domain
          val writes :
            Wp.Sigs.Sigma.t Wp.Sigs.sequence -> Wp.Sigs.Sigma.domain
        end
      module type Model =
        sig
          val configure : unit -> Wp.WpContext.rollback
          val configure_ia :
            Interpreted_automata.automaton ->
            Interpreted_automata.vertex Wp.Sigs.binder
          val datatype : string
          val hypotheses :
            Wp.MemoryContext.partition -> Wp.MemoryContext.partition
          module Chunk : Chunk
          module Heap :
            sig
              type t = Chunk.t
              type set
              type 'a map
              val hash : t -> int
              val equal : t -> t -> bool
              val compare : t -> t -> int
              module Map :
                sig
                  type key = t
                  type 'a t = 'a map
                  val empty : 'a t
                  val add : key -> '-> 'a t -> 'a t
                  val mem : key -> 'a t -> bool
                  val find : key -> 'a t -> 'a
                  val findk : key -> 'a t -> key * 'a
                  val size : 'a t -> int
                  val is_empty : 'a t -> bool
                  val insert :
                    (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                  val change :
                    (key -> '-> 'a option -> 'a option) ->
                    key -> '-> 'a t -> 'a t
                  val map : ('-> 'b) -> 'a t -> 'b t
                  val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                  val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                  val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                  val fold_sorted :
                    (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                  val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val interf :
                    (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                  val interq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val diffq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val subset :
                    (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iterk :
                    (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                  val iter2 :
                    (key -> 'a option -> 'b option -> unit) ->
                    'a t -> 'b t -> unit
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  type domain = set
                  val domain : 'a t -> domain
                end
              module Set :
                sig
                  type elt = t
                  type t = set
                  val empty : t
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val elements : t -> elt list
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val filter : (elt -> bool) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val iter_sorted : (elt -> unit) -> t -> unit
                  val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val subset : t -> t -> bool
                  val intersect : t -> t -> bool
                  val of_list : elt list -> t
                  type 'a mapping = 'a map
                  val mapping : (elt -> 'a) -> t -> 'a mapping
                end
            end
          module Sigma :
            sig
              type chunk = Chunk.t
              module Chunk :
                sig
                  type t = Chunk.t
                  type set = Heap.set
                  type 'a map = 'Heap.map
                  val hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  module Map :
                    sig
                      type key = t
                      type 'a t = 'a map
                      val empty : 'a t
                      val add : key -> '-> 'a t -> 'a t
                      val mem : key -> 'a t -> bool
                      val find : key -> 'a t -> 'a
                      val findk : key -> 'a t -> key * 'a
                      val size : 'a t -> int
                      val is_empty : 'a t -> bool
                      val insert :
                        (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                      val change :
                        (key -> '-> 'a option -> 'a option) ->
                        key -> '-> 'a t -> 'a t
                      val map : ('-> 'b) -> 'a t -> 'b t
                      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                      val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                      val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                      val filter : (key -> '-> bool) -> 'a t -> 'a t
                      val partition :
                        (key -> '-> bool) -> 'a t -> 'a t * 'a t
                      val iter : (key -> '-> unit) -> 'a t -> unit
                      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                      val fold_sorted :
                        (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                      val union :
                        (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                      val inter :
                        (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val interf :
                        (key -> '-> '-> 'c option) ->
                        'a t -> 'b t -> 'c t
                      val interq :
                        (key -> '-> '-> 'a option) ->
                        'a t -> 'a t -> 'a t
                      val diffq :
                        (key -> '-> '-> 'a option) ->
                        'a t -> 'a t -> 'a t
                      val subset :
                        (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val iterk :
                        (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                      val iter2 :
                        (key -> 'a option -> 'b option -> unit) ->
                        'a t -> 'b t -> unit
                      val merge :
                        (key -> 'a option -> 'b option -> 'c option) ->
                        'a t -> 'b t -> 'c t
                      type domain = set
                      val domain : 'a t -> domain
                    end
                  module Set :
                    sig
                      type elt = t
                      type t = set
                      val empty : t
                      val add : elt -> t -> t
                      val singleton : elt -> t
                      val elements : t -> elt list
                      val is_empty : t -> bool
                      val mem : elt -> t -> bool
                      val iter : (elt -> unit) -> t -> unit
                      val fold : (elt -> '-> 'a) -> t -> '-> 'a
                      val filter : (elt -> bool) -> t -> t
                      val partition : (elt -> bool) -> t -> t * t
                      val for_all : (elt -> bool) -> t -> bool
                      val exists : (elt -> bool) -> t -> bool
                      val iter_sorted : (elt -> unit) -> t -> unit
                      val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val subset : t -> t -> bool
                      val intersect : t -> t -> bool
                      val of_list : elt list -> t
                      type 'a mapping = 'a map
                      val mapping : (elt -> 'a) -> t -> 'a mapping
                    end
                end
              type domain = Chunk.Set.t
              type t
              val pretty : Format.formatter -> t -> unit
              val create : unit -> t
              val mem : t -> chunk -> bool
              val get : t -> chunk -> Lang.F.var
              val value : t -> chunk -> Lang.F.term
              val copy : t -> t
              val join : t -> t -> Passive.t
              val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
              val choose : t -> t -> t
              val merge : t -> t -> t * Passive.t * Passive.t
              val merge_list : t list -> t * Passive.t list
              val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
              val iter2 :
                (chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
                t -> t -> unit
              val havoc_chunk : t -> chunk -> t
              val havoc : t -> domain -> t
              val havoc_any : call:bool -> t -> t
              val remove_chunks : t -> domain -> t
              val domain : t -> domain
              val union : domain -> domain -> domain
              val empty : domain
              val writes : t sequence -> domain
            end
          type loc
          type chunk = Wp.Sigs.Chunk.t
          type sigma = Wp.Sigs.Model.Sigma.t
          type domain = Wp.Sigs.Model.Sigma.domain
          type segment = Wp.Sigs.Model.loc Wp.Sigs.rloc
          type state
          val state : Wp.Sigs.Model.sigma -> Wp.Sigs.Model.state
          val lookup : Wp.Sigs.Model.state -> Wp.Lang.F.term -> Wp.Sigs.mval
          val updates :
            Wp.Sigs.Model.state Wp.Sigs.sequence ->
            Wp.Lang.F.Vars.t -> Wp.Sigs.update Bag.t
          val apply :
            (Wp.Lang.F.term -> Wp.Lang.F.term) ->
            Wp.Sigs.Model.state -> Wp.Sigs.Model.state
          val iter :
            (Wp.Sigs.mval -> Wp.Lang.F.term -> unit) ->
            Wp.Sigs.Model.state -> unit
          val pretty : Stdlib.Format.formatter -> Wp.Sigs.Model.loc -> unit
          val vars : Wp.Sigs.Model.loc -> Wp.Lang.F.Vars.t
          val occurs : Wp.Lang.F.var -> Wp.Sigs.Model.loc -> bool
          val null : Wp.Sigs.Model.loc
          val literal : eid:int -> Wp.Cstring.cst -> Wp.Sigs.Model.loc
          val cvar : Cil_types.varinfo -> Wp.Sigs.Model.loc
          val pointer_loc : Wp.Lang.F.term -> Wp.Sigs.Model.loc
          val pointer_val : Wp.Sigs.Model.loc -> Wp.Lang.F.term
          val field :
            Wp.Sigs.Model.loc -> Cil_types.fieldinfo -> Wp.Sigs.Model.loc
          val shift :
            Wp.Sigs.Model.loc ->
            Wp.Ctypes.c_object -> Wp.Lang.F.term -> Wp.Sigs.Model.loc
          val base_addr : Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc
          val base_offset : Wp.Sigs.Model.loc -> Wp.Lang.F.term
          val block_length :
            Wp.Sigs.Model.sigma ->
            Wp.Ctypes.c_object -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
          val cast :
            Wp.Ctypes.c_object Wp.Sigs.sequence ->
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc
          val loc_of_int :
            Wp.Ctypes.c_object -> Wp.Lang.F.term -> Wp.Sigs.Model.loc
          val int_of_loc :
            Wp.Ctypes.c_int -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
          val domain :
            Wp.Ctypes.c_object -> Wp.Sigs.Model.loc -> Wp.Sigs.Model.domain
          val is_well_formed : Wp.Sigs.Model.sigma -> Wp.Lang.F.pred
          val load :
            Wp.Sigs.Model.sigma ->
            Wp.Ctypes.c_object ->
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc Wp.Sigs.value
          val load_init :
            Wp.Sigs.Model.sigma ->
            Wp.Ctypes.c_object -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
          val copied :
            Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
            Wp.Ctypes.c_object ->
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Sigs.equation list
          val copied_init :
            Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
            Wp.Ctypes.c_object ->
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Sigs.equation list
          val stored :
            Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
            Wp.Ctypes.c_object ->
            Wp.Sigs.Model.loc -> Wp.Lang.F.term -> Wp.Sigs.equation list
          val stored_init :
            Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
            Wp.Ctypes.c_object ->
            Wp.Sigs.Model.loc -> Wp.Lang.F.term -> Wp.Sigs.equation list
          val assigned :
            Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
            Wp.Ctypes.c_object ->
            Wp.Sigs.Model.loc Wp.Sigs.sloc -> Wp.Sigs.equation list
          val is_null : Wp.Sigs.Model.loc -> Wp.Lang.F.pred
          val loc_eq :
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
          val loc_lt :
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
          val loc_neq :
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
          val loc_leq :
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.pred
          val loc_diff :
            Wp.Ctypes.c_object ->
            Wp.Sigs.Model.loc -> Wp.Sigs.Model.loc -> Wp.Lang.F.term
          val valid :
            Wp.Sigs.Model.sigma ->
            Wp.Sigs.acs -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
          val frame : Wp.Sigs.Model.sigma -> Wp.Lang.F.pred list
          val alloc :
            Wp.Sigs.Model.sigma ->
            Cil_types.varinfo list -> Wp.Sigs.Model.sigma
          val initialized :
            Wp.Sigs.Model.sigma -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
          val invalid :
            Wp.Sigs.Model.sigma -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
          val scope :
            Wp.Sigs.Model.sigma Wp.Sigs.sequence ->
            Wp.Sigs.scope -> Cil_types.varinfo list -> Wp.Lang.F.pred list
          val global :
            Wp.Sigs.Model.sigma -> Wp.Lang.F.term -> Wp.Lang.F.pred
          val included :
            Wp.Sigs.Model.segment -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
          val separated :
            Wp.Sigs.Model.segment -> Wp.Sigs.Model.segment -> Wp.Lang.F.pred
        end
      module type CodeSemantics =
        sig
          module M : Model
          type loc = M.loc
          type nonrec value = Wp.Sigs.CodeSemantics.loc Wp.Sigs.value
          type nonrec result = Wp.Sigs.CodeSemantics.loc Wp.Sigs.result
          type sigma = M.Sigma.t
          val pp_value :
            Stdlib.Format.formatter -> Wp.Sigs.CodeSemantics.value -> unit
          val cval : Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.term
          val cloc : Wp.Sigs.CodeSemantics.value -> Wp.Sigs.CodeSemantics.loc
          val cast :
            Cil_types.typ ->
            Cil_types.typ ->
            Wp.Sigs.CodeSemantics.value -> Wp.Sigs.CodeSemantics.value
          val equal_typ :
            Cil_types.typ ->
            Wp.Sigs.CodeSemantics.value ->
            Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
          val not_equal_typ :
            Cil_types.typ ->
            Wp.Sigs.CodeSemantics.value ->
            Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
          val equal_obj :
            Wp.Ctypes.c_object ->
            Wp.Sigs.CodeSemantics.value ->
            Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
          val not_equal_obj :
            Wp.Ctypes.c_object ->
            Wp.Sigs.CodeSemantics.value ->
            Wp.Sigs.CodeSemantics.value -> Wp.Lang.F.pred
          val exp :
            Wp.Sigs.CodeSemantics.sigma ->
            Cil_types.exp -> Wp.Sigs.CodeSemantics.value
          val cond :
            Wp.Sigs.CodeSemantics.sigma -> Cil_types.exp -> Wp.Lang.F.pred
          val lval :
            Wp.Sigs.CodeSemantics.sigma ->
            Cil_types.lval -> Wp.Sigs.CodeSemantics.loc
          val call :
            Wp.Sigs.CodeSemantics.sigma ->
            Cil_types.exp -> Wp.Sigs.CodeSemantics.loc
          val instance_of :
            Wp.Sigs.CodeSemantics.loc ->
            Cil_types.kernel_function -> Wp.Lang.F.pred
          val loc_of_exp :
            Wp.Sigs.CodeSemantics.sigma ->
            Cil_types.exp -> Wp.Sigs.CodeSemantics.loc
          val val_of_exp :
            Wp.Sigs.CodeSemantics.sigma -> Cil_types.exp -> Wp.Lang.F.term
          val result :
            Wp.Sigs.CodeSemantics.sigma ->
            Cil_types.typ -> Wp.Sigs.CodeSemantics.result -> Wp.Lang.F.term
          val return :
            Wp.Sigs.CodeSemantics.sigma ->
            Cil_types.typ -> Cil_types.exp -> Wp.Lang.F.term
          val is_zero :
            Wp.Sigs.CodeSemantics.sigma ->
            Wp.Ctypes.c_object -> Wp.Sigs.CodeSemantics.loc -> Wp.Lang.F.pred
          val is_exp_range :
            Wp.Sigs.CodeSemantics.sigma ->
            Wp.Sigs.CodeSemantics.loc ->
            Wp.Ctypes.c_object ->
            Wp.Lang.F.term ->
            Wp.Lang.F.term ->
            Wp.Sigs.CodeSemantics.value option -> Wp.Lang.F.pred
          val unchanged :
            M.sigma -> M.sigma -> Cil_types.varinfo -> Wp.Lang.F.pred
          type warned_hyp =
              Wp.Warning.Set.t * (Wp.Lang.F.pred * Wp.Lang.F.pred)
          val init :
            sigma:M.sigma ->
            Cil_types.varinfo ->
            Cil_types.init option -> Wp.Sigs.CodeSemantics.warned_hyp list
        end
      module type LogicSemantics =
        sig
          module M : Model
          type loc = M.loc
          type nonrec value = M.loc Wp.Sigs.value
          type nonrec logic = M.loc Wp.Sigs.logic
          type nonrec region = M.loc Wp.Sigs.region
          type nonrec result = M.loc Wp.Sigs.result
          type sigma = M.Sigma.t
          type frame
          val pp_frame :
            Stdlib.Format.formatter -> Wp.Sigs.LogicSemantics.frame -> unit
          val get_frame : unit -> Wp.Sigs.LogicSemantics.frame
          val in_frame :
            Wp.Sigs.LogicSemantics.frame -> ('-> 'b) -> '-> 'b
          val mem_at_frame :
            Wp.Sigs.LogicSemantics.frame ->
            Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma
          val set_at_frame :
            Wp.Sigs.LogicSemantics.frame ->
            Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma -> unit
          val has_at_frame :
            Wp.Sigs.LogicSemantics.frame -> Wp.Clabels.c_label -> bool
          val mem_frame : Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma
          val mk_frame :
            ?kf:Cil_types.kernel_function ->
            ?result:Wp.Sigs.LogicSemantics.result ->
            ?status:Wp.Lang.F.var ->
            ?formals:Wp.Sigs.LogicSemantics.value Cil_datatype.Varinfo.Map.t ->
            ?labels:Wp.Sigs.LogicSemantics.sigma Wp.Clabels.LabelMap.t ->
            ?descr:string -> unit -> Wp.Sigs.LogicSemantics.frame
          val local : descr:string -> Wp.Sigs.LogicSemantics.frame
          val frame :
            Cil_types.kernel_function -> Wp.Sigs.LogicSemantics.frame
          type call
          val call :
            ?result:M.loc ->
            Cil_types.kernel_function ->
            Wp.Sigs.LogicSemantics.value list -> Wp.Sigs.LogicSemantics.call
          val call_pre :
            Wp.Sigs.LogicSemantics.sigma ->
            Wp.Sigs.LogicSemantics.call ->
            Wp.Sigs.LogicSemantics.sigma -> Wp.Sigs.LogicSemantics.frame
          val call_post :
            Wp.Sigs.LogicSemantics.sigma ->
            Wp.Sigs.LogicSemantics.call ->
            Wp.Sigs.LogicSemantics.sigma Wp.Sigs.sequence ->
            Wp.Sigs.LogicSemantics.frame
          val return : unit -> Cil_types.typ
          val result : unit -> Wp.Sigs.LogicSemantics.result
          val status : unit -> Wp.Lang.F.var
          val guards : Wp.Sigs.LogicSemantics.frame -> Wp.Lang.F.pred list
          type env
          val mk_env :
            ?here:Wp.Sigs.LogicSemantics.sigma ->
            ?lvars:Cil_types.logic_var list ->
            unit -> Wp.Sigs.LogicSemantics.env
          val current :
            Wp.Sigs.LogicSemantics.env -> Wp.Sigs.LogicSemantics.sigma
          val move_at :
            Wp.Sigs.LogicSemantics.env ->
            Wp.Sigs.LogicSemantics.sigma -> Wp.Sigs.LogicSemantics.env
          val mem_at :
            Wp.Sigs.LogicSemantics.env ->
            Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.sigma
          val env_at :
            Wp.Sigs.LogicSemantics.env ->
            Wp.Clabels.c_label -> Wp.Sigs.LogicSemantics.env
          val lval :
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.term_lval -> Cil_types.typ * M.loc
          val term :
            Wp.Sigs.LogicSemantics.env -> Cil_types.term -> Wp.Lang.F.term
          val pred :
            Wp.Sigs.polarity ->
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.predicate -> Wp.Lang.F.pred
          val call_pred :
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.logic_info ->
            Cil_types.logic_label list ->
            Wp.Lang.F.term list -> Wp.Lang.F.pred
          val region :
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.term -> Wp.Sigs.LogicSemantics.region
          val assigned_of_lval :
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.lval -> Wp.Sigs.LogicSemantics.region
          val assigned_of_froms :
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.from list -> Wp.Sigs.LogicSemantics.region
          val assigned_of_assigns :
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.assigns -> Wp.Sigs.LogicSemantics.region option
          val val_of_term :
            Wp.Sigs.LogicSemantics.env -> Cil_types.term -> Wp.Lang.F.term
          val loc_of_term :
            Wp.Sigs.LogicSemantics.env ->
            Cil_types.term -> Wp.Sigs.LogicSemantics.loc
          val lemma : Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma
          val vars : Wp.Sigs.LogicSemantics.region -> Wp.Lang.F.Vars.t
          val occurs : Wp.Lang.F.var -> Wp.Sigs.LogicSemantics.region -> bool
          val check_assigns :
            unfold:int ->
            Wp.Sigs.LogicSemantics.sigma ->
            written:Wp.Sigs.LogicSemantics.region ->
            assignable:Wp.Sigs.LogicSemantics.region -> Wp.Lang.F.pred
        end
      module type LogicAssigns =
        sig
          module M : Model
          module L :
            sig
              module M :
                sig
                  val configure : unit -> WpContext.rollback
                  val configure_ia :
                    Interpreted_automata.automaton ->
                    Interpreted_automata.vertex binder
                  val datatype : string
                  val hypotheses :
                    MemoryContext.partition -> MemoryContext.partition
                  module Chunk :
                    sig
                      type t = M.Chunk.t
                      val self : string
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val pretty : Format.formatter -> t -> unit
                      val tau_of_chunk : t -> Lang.F.tau
                      val basename_of_chunk : t -> string
                      val is_framed : t -> bool
                    end
                  module Heap :
                    sig
                      type t = Chunk.t
                      type set = M.Heap.set
                      type 'a map = 'M.Heap.map
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      module Map :
                        sig
                          type key = t
                          type 'a t = 'a map
                          val empty : 'a t
                          val add : key -> '-> 'a t -> 'a t
                          val mem : key -> 'a t -> bool
                          val find : key -> 'a t -> 'a
                          val findk : key -> 'a t -> key * 'a
                          val size : 'a t -> int
                          val is_empty : 'a t -> bool
                          val insert :
                            (key -> '-> '-> 'a) ->
                            key -> '-> 'a t -> 'a t
                          val change :
                            (key -> '-> 'a option -> 'a option) ->
                            key -> '-> 'a t -> 'a t
                          val map : ('-> 'b) -> 'a t -> 'b t
                          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                          val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                          val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                          val filter : (key -> '-> bool) -> 'a t -> 'a t
                          val partition :
                            (key -> '-> bool) -> 'a t -> 'a t * 'a t
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val iter_sorted :
                            (key -> '-> unit) -> 'a t -> unit
                          val fold_sorted :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val union :
                            (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                          val inter :
                            (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val interf :
                            (key -> '-> '-> 'c option) ->
                            'a t -> 'b t -> 'c t
                          val interq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val diffq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val subset :
                            (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val iterk :
                            (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                          val iter2 :
                            (key -> 'a option -> 'b option -> unit) ->
                            'a t -> 'b t -> unit
                          val merge :
                            (key -> 'a option -> 'b option -> 'c option) ->
                            'a t -> 'b t -> 'c t
                          type domain = set
                          val domain : 'a t -> domain
                        end
                      module Set :
                        sig
                          type elt = t
                          type t = set
                          val empty : t
                          val add : elt -> t -> t
                          val singleton : elt -> t
                          val elements : t -> elt list
                          val is_empty : t -> bool
                          val mem : elt -> t -> bool
                          val iter : (elt -> unit) -> t -> unit
                          val fold : (elt -> '-> 'a) -> t -> '-> 'a
                          val filter : (elt -> bool) -> t -> t
                          val partition : (elt -> bool) -> t -> t * t
                          val for_all : (elt -> bool) -> t -> bool
                          val exists : (elt -> bool) -> t -> bool
                          val iter_sorted : (elt -> unit) -> t -> unit
                          val fold_sorted :
                            (elt -> '-> 'a) -> t -> '-> 'a
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val subset : t -> t -> bool
                          val intersect : t -> t -> bool
                          val of_list : elt list -> t
                          type 'a mapping = 'a map
                          val mapping : (elt -> 'a) -> t -> 'a mapping
                        end
                    end
                  module Sigma :
                    sig
                      type chunk = Chunk.t
                      module Chunk :
                        sig
                          type t = Chunk.t
                          type set = Heap.set
                          type 'a map = 'Heap.map
                          val hash : t -> int
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          module Map :
                            sig
                              type key = t
                              type 'a t = 'a map
                              val empty : 'a t
                              val add : key -> '-> 'a t -> 'a t
                              val mem : key -> 'a t -> bool
                              val find : key -> 'a t -> 'a
                              val findk : key -> 'a t -> key * 'a
                              val size : 'a t -> int
                              val is_empty : 'a t -> bool
                              val insert :
                                (key -> '-> '-> 'a) ->
                                key -> '-> 'a t -> 'a t
                              val change :
                                (key -> '-> 'a option -> 'a option) ->
                                key -> '-> 'a t -> 'a t
                              val map : ('-> 'b) -> 'a t -> 'b t
                              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                              val mapf :
                                (key -> '-> 'b option) -> 'a t -> 'b t
                              val mapq :
                                (key -> '-> 'a option) -> 'a t -> 'a t
                              val filter :
                                (key -> '-> bool) -> 'a t -> 'a t
                              val partition :
                                (key -> '-> bool) -> 'a t -> 'a t * 'a t
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val iter_sorted :
                                (key -> '-> unit) -> 'a t -> unit
                              val fold_sorted :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val union :
                                (key -> '-> '-> 'a) ->
                                'a t -> 'a t -> 'a t
                              val inter :
                                (key -> '-> '-> 'c) ->
                                'a t -> 'b t -> 'c t
                              val interf :
                                (key -> '-> '-> 'c option) ->
                                'a t -> 'b t -> 'c t
                              val interq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val diffq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val subset :
                                (key -> '-> '-> bool) ->
                                'a t -> 'b t -> bool
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val iterk :
                                (key -> '-> '-> unit) ->
                                'a t -> 'b t -> unit
                              val iter2 :
                                (key -> 'a option -> 'b option -> unit) ->
                                'a t -> 'b t -> unit
                              val merge :
                                (key -> 'a option -> 'b option -> 'c option) ->
                                'a t -> 'b t -> 'c t
                              type domain = set
                              val domain : 'a t -> domain
                            end
                          module Set :
                            sig
                              type elt = t
                              type t = set
                              val empty : t
                              val add : elt -> t -> t
                              val singleton : elt -> t
                              val elements : t -> elt list
                              val is_empty : t -> bool
                              val mem : elt -> t -> bool
                              val iter : (elt -> unit) -> t -> unit
                              val fold : (elt -> '-> 'a) -> t -> '-> 'a
                              val filter : (elt -> bool) -> t -> t
                              val partition : (elt -> bool) -> t -> t * t
                              val for_all : (elt -> bool) -> t -> bool
                              val exists : (elt -> bool) -> t -> bool
                              val iter_sorted : (elt -> unit) -> t -> unit
                              val fold_sorted :
                                (elt -> '-> 'a) -> t -> '-> 'a
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val subset : t -> t -> bool
                              val intersect : t -> t -> bool
                              val of_list : elt list -> t
                              type 'a mapping = 'a map
                              val mapping : (elt -> 'a) -> t -> 'a mapping
                            end
                        end
                      type domain = Chunk.Set.t
                      type t = M.Sigma.t
                      val pretty : Format.formatter -> t -> unit
                      val create : unit -> t
                      val mem : t -> chunk -> bool
                      val get : t -> chunk -> Lang.F.var
                      val value : t -> chunk -> Lang.F.term
                      val copy : t -> t
                      val join : t -> t -> Passive.t
                      val assigned :
                        pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                      val choose : t -> t -> t
                      val merge : t -> t -> t * Passive.t * Passive.t
                      val merge_list : t list -> t * Passive.t list
                      val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                      val iter2 :
                        (chunk ->
                         Lang.F.var option -> Lang.F.var option -> unit) ->
                        t -> t -> unit
                      val havoc_chunk : t -> chunk -> t
                      val havoc : t -> domain -> t
                      val havoc_any : call:bool -> t -> t
                      val remove_chunks : t -> domain -> t
                      val domain : t -> domain
                      val union : domain -> domain -> domain
                      val empty : domain
                      val writes : t sequence -> domain
                    end
                  type loc = M.loc
                  type chunk = Chunk.t
                  type sigma = Sigma.t
                  type domain = Sigma.domain
                  type segment = loc rloc
                  type state = M.state
                  val state : sigma -> state
                  val lookup : state -> Lang.F.term -> mval
                  val updates :
                    state sequence -> Lang.F.Vars.t -> update Bag.t
                  val apply : (Lang.F.term -> Lang.F.term) -> state -> state
                  val iter : (mval -> Lang.F.term -> unit) -> state -> unit
                  val pretty : Format.formatter -> loc -> unit
                  val vars : loc -> Lang.F.Vars.t
                  val occurs : Lang.F.var -> loc -> bool
                  val null : loc
                  val literal : eid:int -> Cstring.cst -> loc
                  val cvar : Cil_types.varinfo -> loc
                  val pointer_loc : Lang.F.term -> loc
                  val pointer_val : loc -> Lang.F.term
                  val field : loc -> Cil_types.fieldinfo -> loc
                  val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
                  val base_addr : loc -> loc
                  val base_offset : loc -> Lang.F.term
                  val block_length :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val cast : Ctypes.c_object sequence -> loc -> loc
                  val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
                  val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
                  val domain : Ctypes.c_object -> loc -> domain
                  val is_well_formed : sigma -> Lang.F.pred
                  val load : sigma -> Ctypes.c_object -> loc -> loc value
                  val load_init :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val copied :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val copied_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val stored :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val stored_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val assigned :
                    sigma sequence ->
                    Ctypes.c_object -> loc sloc -> equation list
                  val is_null : loc -> Lang.F.pred
                  val loc_eq : loc -> loc -> Lang.F.pred
                  val loc_lt : loc -> loc -> Lang.F.pred
                  val loc_neq : loc -> loc -> Lang.F.pred
                  val loc_leq : loc -> loc -> Lang.F.pred
                  val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
                  val valid : sigma -> acs -> segment -> Lang.F.pred
                  val frame : sigma -> Lang.F.pred list
                  val alloc : sigma -> Cil_types.varinfo list -> sigma
                  val initialized : sigma -> segment -> Lang.F.pred
                  val invalid : sigma -> segment -> Lang.F.pred
                  val scope :
                    sigma sequence ->
                    scope -> Cil_types.varinfo list -> Lang.F.pred list
                  val global : sigma -> Lang.F.term -> Lang.F.pred
                  val included : segment -> segment -> Lang.F.pred
                  val separated : segment -> segment -> Lang.F.pred
                end
              type loc = M.loc
              type nonrec value = M.loc value
              type nonrec logic = M.loc logic
              type nonrec region = M.loc region
              type nonrec result = M.loc result
              type sigma = M.Sigma.t
              type frame
              val pp_frame : Format.formatter -> frame -> unit
              val get_frame : unit -> frame
              val in_frame : frame -> ('-> 'b) -> '-> 'b
              val mem_at_frame : frame -> Clabels.c_label -> sigma
              val set_at_frame : frame -> Clabels.c_label -> sigma -> unit
              val has_at_frame : frame -> Clabels.c_label -> bool
              val mem_frame : Clabels.c_label -> sigma
              val mk_frame :
                ?kf:Cil_types.kernel_function ->
                ?result:result ->
                ?status:Lang.F.var ->
                ?formals:value Cil_datatype.Varinfo.Map.t ->
                ?labels:sigma Clabels.LabelMap.t ->
                ?descr:string -> unit -> frame
              val local : descr:string -> frame
              val frame : Cil_types.kernel_function -> frame
              type call
              val call :
                ?result:M.loc ->
                Cil_types.kernel_function -> value list -> call
              val call_pre : sigma -> call -> sigma -> frame
              val call_post : sigma -> call -> sigma sequence -> frame
              val return : unit -> Cil_types.typ
              val result : unit -> result
              val status : unit -> Lang.F.var
              val guards : frame -> Lang.F.pred list
              type env
              val mk_env :
                ?here:sigma -> ?lvars:Cil_types.logic_var list -> unit -> env
              val current : env -> sigma
              val move_at : env -> sigma -> env
              val mem_at : env -> Clabels.c_label -> sigma
              val env_at : env -> Clabels.c_label -> env
              val lval : env -> Cil_types.term_lval -> Cil_types.typ * M.loc
              val term : env -> Cil_types.term -> Lang.F.term
              val pred :
                polarity -> env -> Cil_types.predicate -> Lang.F.pred
              val call_pred :
                env ->
                Cil_types.logic_info ->
                Cil_types.logic_label list -> Lang.F.term list -> Lang.F.pred
              val region : env -> Cil_types.term -> region
              val assigned_of_lval : env -> Cil_types.lval -> region
              val assigned_of_froms : env -> Cil_types.from list -> region
              val assigned_of_assigns :
                env -> Cil_types.assigns -> region option
              val val_of_term : env -> Cil_types.term -> Lang.F.term
              val loc_of_term : env -> Cil_types.term -> loc
              val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
              val vars : region -> Lang.F.Vars.t
              val occurs : Lang.F.var -> region -> bool
              val check_assigns :
                unfold:int ->
                sigma -> written:region -> assignable:region -> Lang.F.pred
            end
          val domain : M.loc Wp.Sigs.region -> M.Heap.set
          val apply_assigns :
            M.sigma Wp.Sigs.sequence ->
            M.loc Wp.Sigs.region -> Wp.Lang.F.pred list
        end
      module type Compiler =
        sig
          module M : Model
          module C :
            sig
              module M :
                sig
                  val configure : unit -> WpContext.rollback
                  val configure_ia :
                    Interpreted_automata.automaton ->
                    Interpreted_automata.vertex binder
                  val datatype : string
                  val hypotheses :
                    MemoryContext.partition -> MemoryContext.partition
                  module Chunk :
                    sig
                      type t = M.Chunk.t
                      val self : string
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val pretty : Format.formatter -> t -> unit
                      val tau_of_chunk : t -> Lang.F.tau
                      val basename_of_chunk : t -> string
                      val is_framed : t -> bool
                    end
                  module Heap :
                    sig
                      type t = Chunk.t
                      type set = M.Heap.set
                      type 'a map = 'M.Heap.map
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      module Map :
                        sig
                          type key = t
                          type 'a t = 'a map
                          val empty : 'a t
                          val add : key -> '-> 'a t -> 'a t
                          val mem : key -> 'a t -> bool
                          val find : key -> 'a t -> 'a
                          val findk : key -> 'a t -> key * 'a
                          val size : 'a t -> int
                          val is_empty : 'a t -> bool
                          val insert :
                            (key -> '-> '-> 'a) ->
                            key -> '-> 'a t -> 'a t
                          val change :
                            (key -> '-> 'a option -> 'a option) ->
                            key -> '-> 'a t -> 'a t
                          val map : ('-> 'b) -> 'a t -> 'b t
                          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                          val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                          val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                          val filter : (key -> '-> bool) -> 'a t -> 'a t
                          val partition :
                            (key -> '-> bool) -> 'a t -> 'a t * 'a t
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val iter_sorted :
                            (key -> '-> unit) -> 'a t -> unit
                          val fold_sorted :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val union :
                            (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                          val inter :
                            (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val interf :
                            (key -> '-> '-> 'c option) ->
                            'a t -> 'b t -> 'c t
                          val interq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val diffq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val subset :
                            (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val iterk :
                            (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                          val iter2 :
                            (key -> 'a option -> 'b option -> unit) ->
                            'a t -> 'b t -> unit
                          val merge :
                            (key -> 'a option -> 'b option -> 'c option) ->
                            'a t -> 'b t -> 'c t
                          type domain = set
                          val domain : 'a t -> domain
                        end
                      module Set :
                        sig
                          type elt = t
                          type t = set
                          val empty : t
                          val add : elt -> t -> t
                          val singleton : elt -> t
                          val elements : t -> elt list
                          val is_empty : t -> bool
                          val mem : elt -> t -> bool
                          val iter : (elt -> unit) -> t -> unit
                          val fold : (elt -> '-> 'a) -> t -> '-> 'a
                          val filter : (elt -> bool) -> t -> t
                          val partition : (elt -> bool) -> t -> t * t
                          val for_all : (elt -> bool) -> t -> bool
                          val exists : (elt -> bool) -> t -> bool
                          val iter_sorted : (elt -> unit) -> t -> unit
                          val fold_sorted :
                            (elt -> '-> 'a) -> t -> '-> 'a
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val subset : t -> t -> bool
                          val intersect : t -> t -> bool
                          val of_list : elt list -> t
                          type 'a mapping = 'a map
                          val mapping : (elt -> 'a) -> t -> 'a mapping
                        end
                    end
                  module Sigma :
                    sig
                      type chunk = Chunk.t
                      module Chunk :
                        sig
                          type t = Chunk.t
                          type set = Heap.set
                          type 'a map = 'Heap.map
                          val hash : t -> int
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          module Map :
                            sig
                              type key = t
                              type 'a t = 'a map
                              val empty : 'a t
                              val add : key -> '-> 'a t -> 'a t
                              val mem : key -> 'a t -> bool
                              val find : key -> 'a t -> 'a
                              val findk : key -> 'a t -> key * 'a
                              val size : 'a t -> int
                              val is_empty : 'a t -> bool
                              val insert :
                                (key -> '-> '-> 'a) ->
                                key -> '-> 'a t -> 'a t
                              val change :
                                (key -> '-> 'a option -> 'a option) ->
                                key -> '-> 'a t -> 'a t
                              val map : ('-> 'b) -> 'a t -> 'b t
                              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                              val mapf :
                                (key -> '-> 'b option) -> 'a t -> 'b t
                              val mapq :
                                (key -> '-> 'a option) -> 'a t -> 'a t
                              val filter :
                                (key -> '-> bool) -> 'a t -> 'a t
                              val partition :
                                (key -> '-> bool) -> 'a t -> 'a t * 'a t
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val iter_sorted :
                                (key -> '-> unit) -> 'a t -> unit
                              val fold_sorted :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val union :
                                (key -> '-> '-> 'a) ->
                                'a t -> 'a t -> 'a t
                              val inter :
                                (key -> '-> '-> 'c) ->
                                'a t -> 'b t -> 'c t
                              val interf :
                                (key -> '-> '-> 'c option) ->
                                'a t -> 'b t -> 'c t
                              val interq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val diffq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val subset :
                                (key -> '-> '-> bool) ->
                                'a t -> 'b t -> bool
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val iterk :
                                (key -> '-> '-> unit) ->
                                'a t -> 'b t -> unit
                              val iter2 :
                                (key -> 'a option -> 'b option -> unit) ->
                                'a t -> 'b t -> unit
                              val merge :
                                (key -> 'a option -> 'b option -> 'c option) ->
                                'a t -> 'b t -> 'c t
                              type domain = set
                              val domain : 'a t -> domain
                            end
                          module Set :
                            sig
                              type elt = t
                              type t = set
                              val empty : t
                              val add : elt -> t -> t
                              val singleton : elt -> t
                              val elements : t -> elt list
                              val is_empty : t -> bool
                              val mem : elt -> t -> bool
                              val iter : (elt -> unit) -> t -> unit
                              val fold : (elt -> '-> 'a) -> t -> '-> 'a
                              val filter : (elt -> bool) -> t -> t
                              val partition : (elt -> bool) -> t -> t * t
                              val for_all : (elt -> bool) -> t -> bool
                              val exists : (elt -> bool) -> t -> bool
                              val iter_sorted : (elt -> unit) -> t -> unit
                              val fold_sorted :
                                (elt -> '-> 'a) -> t -> '-> 'a
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val subset : t -> t -> bool
                              val intersect : t -> t -> bool
                              val of_list : elt list -> t
                              type 'a mapping = 'a map
                              val mapping : (elt -> 'a) -> t -> 'a mapping
                            end
                        end
                      type domain = Chunk.Set.t
                      type t = M.Sigma.t
                      val pretty : Format.formatter -> t -> unit
                      val create : unit -> t
                      val mem : t -> chunk -> bool
                      val get : t -> chunk -> Lang.F.var
                      val value : t -> chunk -> Lang.F.term
                      val copy : t -> t
                      val join : t -> t -> Passive.t
                      val assigned :
                        pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                      val choose : t -> t -> t
                      val merge : t -> t -> t * Passive.t * Passive.t
                      val merge_list : t list -> t * Passive.t list
                      val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                      val iter2 :
                        (chunk ->
                         Lang.F.var option -> Lang.F.var option -> unit) ->
                        t -> t -> unit
                      val havoc_chunk : t -> chunk -> t
                      val havoc : t -> domain -> t
                      val havoc_any : call:bool -> t -> t
                      val remove_chunks : t -> domain -> t
                      val domain : t -> domain
                      val union : domain -> domain -> domain
                      val empty : domain
                      val writes : t sequence -> domain
                    end
                  type loc = M.loc
                  type chunk = Chunk.t
                  type sigma = Sigma.t
                  type domain = Sigma.domain
                  type segment = loc rloc
                  type state = M.state
                  val state : sigma -> state
                  val lookup : state -> Lang.F.term -> mval
                  val updates :
                    state sequence -> Lang.F.Vars.t -> update Bag.t
                  val apply : (Lang.F.term -> Lang.F.term) -> state -> state
                  val iter : (mval -> Lang.F.term -> unit) -> state -> unit
                  val pretty : Format.formatter -> loc -> unit
                  val vars : loc -> Lang.F.Vars.t
                  val occurs : Lang.F.var -> loc -> bool
                  val null : loc
                  val literal : eid:int -> Cstring.cst -> loc
                  val cvar : Cil_types.varinfo -> loc
                  val pointer_loc : Lang.F.term -> loc
                  val pointer_val : loc -> Lang.F.term
                  val field : loc -> Cil_types.fieldinfo -> loc
                  val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
                  val base_addr : loc -> loc
                  val base_offset : loc -> Lang.F.term
                  val block_length :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val cast : Ctypes.c_object sequence -> loc -> loc
                  val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
                  val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
                  val domain : Ctypes.c_object -> loc -> domain
                  val is_well_formed : sigma -> Lang.F.pred
                  val load : sigma -> Ctypes.c_object -> loc -> loc value
                  val load_init :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val copied :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val copied_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val stored :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val stored_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val assigned :
                    sigma sequence ->
                    Ctypes.c_object -> loc sloc -> equation list
                  val is_null : loc -> Lang.F.pred
                  val loc_eq : loc -> loc -> Lang.F.pred
                  val loc_lt : loc -> loc -> Lang.F.pred
                  val loc_neq : loc -> loc -> Lang.F.pred
                  val loc_leq : loc -> loc -> Lang.F.pred
                  val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
                  val valid : sigma -> acs -> segment -> Lang.F.pred
                  val frame : sigma -> Lang.F.pred list
                  val alloc : sigma -> Cil_types.varinfo list -> sigma
                  val initialized : sigma -> segment -> Lang.F.pred
                  val invalid : sigma -> segment -> Lang.F.pred
                  val scope :
                    sigma sequence ->
                    scope -> Cil_types.varinfo list -> Lang.F.pred list
                  val global : sigma -> Lang.F.term -> Lang.F.pred
                  val included : segment -> segment -> Lang.F.pred
                  val separated : segment -> segment -> Lang.F.pred
                end
              type loc = M.loc
              type nonrec value = loc value
              type nonrec result = loc result
              type sigma = M.Sigma.t
              val pp_value : Format.formatter -> value -> unit
              val cval : value -> Lang.F.term
              val cloc : value -> loc
              val cast : Cil_types.typ -> Cil_types.typ -> value -> value
              val equal_typ : Cil_types.typ -> value -> value -> Lang.F.pred
              val not_equal_typ :
                Cil_types.typ -> value -> value -> Lang.F.pred
              val equal_obj :
                Ctypes.c_object -> value -> value -> Lang.F.pred
              val not_equal_obj :
                Ctypes.c_object -> value -> value -> Lang.F.pred
              val exp : sigma -> Cil_types.exp -> value
              val cond : sigma -> Cil_types.exp -> Lang.F.pred
              val lval : sigma -> Cil_types.lval -> loc
              val call : sigma -> Cil_types.exp -> loc
              val instance_of :
                loc -> Cil_types.kernel_function -> Lang.F.pred
              val loc_of_exp : sigma -> Cil_types.exp -> loc
              val val_of_exp : sigma -> Cil_types.exp -> Lang.F.term
              val result : sigma -> Cil_types.typ -> result -> Lang.F.term
              val return :
                sigma -> Cil_types.typ -> Cil_types.exp -> Lang.F.term
              val is_zero : sigma -> Ctypes.c_object -> loc -> Lang.F.pred
              val is_exp_range :
                sigma ->
                loc ->
                Ctypes.c_object ->
                Lang.F.term -> Lang.F.term -> value option -> Lang.F.pred
              val unchanged :
                M.sigma -> M.sigma -> Cil_types.varinfo -> Lang.F.pred
              type warned_hyp = Warning.Set.t * (Lang.F.pred * Lang.F.pred)
              val init :
                sigma:M.sigma ->
                Cil_types.varinfo -> Cil_types.init option -> warned_hyp list
            end
          module L :
            sig
              module M :
                sig
                  val configure : unit -> WpContext.rollback
                  val configure_ia :
                    Interpreted_automata.automaton ->
                    Interpreted_automata.vertex binder
                  val datatype : string
                  val hypotheses :
                    MemoryContext.partition -> MemoryContext.partition
                  module Chunk :
                    sig
                      type t = M.Chunk.t
                      val self : string
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val pretty : Format.formatter -> t -> unit
                      val tau_of_chunk : t -> Lang.F.tau
                      val basename_of_chunk : t -> string
                      val is_framed : t -> bool
                    end
                  module Heap :
                    sig
                      type t = Chunk.t
                      type set = M.Heap.set
                      type 'a map = 'M.Heap.map
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      module Map :
                        sig
                          type key = t
                          type 'a t = 'a map
                          val empty : 'a t
                          val add : key -> '-> 'a t -> 'a t
                          val mem : key -> 'a t -> bool
                          val find : key -> 'a t -> 'a
                          val findk : key -> 'a t -> key * 'a
                          val size : 'a t -> int
                          val is_empty : 'a t -> bool
                          val insert :
                            (key -> '-> '-> 'a) ->
                            key -> '-> 'a t -> 'a t
                          val change :
                            (key -> '-> 'a option -> 'a option) ->
                            key -> '-> 'a t -> 'a t
                          val map : ('-> 'b) -> 'a t -> 'b t
                          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                          val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                          val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                          val filter : (key -> '-> bool) -> 'a t -> 'a t
                          val partition :
                            (key -> '-> bool) -> 'a t -> 'a t * 'a t
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val iter_sorted :
                            (key -> '-> unit) -> 'a t -> unit
                          val fold_sorted :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val union :
                            (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                          val inter :
                            (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val interf :
                            (key -> '-> '-> 'c option) ->
                            'a t -> 'b t -> 'c t
                          val interq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val diffq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val subset :
                            (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val iterk :
                            (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                          val iter2 :
                            (key -> 'a option -> 'b option -> unit) ->
                            'a t -> 'b t -> unit
                          val merge :
                            (key -> 'a option -> 'b option -> 'c option) ->
                            'a t -> 'b t -> 'c t
                          type domain = set
                          val domain : 'a t -> domain
                        end
                      module Set :
                        sig
                          type elt = t
                          type t = set
                          val empty : t
                          val add : elt -> t -> t
                          val singleton : elt -> t
                          val elements : t -> elt list
                          val is_empty : t -> bool
                          val mem : elt -> t -> bool
                          val iter : (elt -> unit) -> t -> unit
                          val fold : (elt -> '-> 'a) -> t -> '-> 'a
                          val filter : (elt -> bool) -> t -> t
                          val partition : (elt -> bool) -> t -> t * t
                          val for_all : (elt -> bool) -> t -> bool
                          val exists : (elt -> bool) -> t -> bool
                          val iter_sorted : (elt -> unit) -> t -> unit
                          val fold_sorted :
                            (elt -> '-> 'a) -> t -> '-> 'a
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val subset : t -> t -> bool
                          val intersect : t -> t -> bool
                          val of_list : elt list -> t
                          type 'a mapping = 'a map
                          val mapping : (elt -> 'a) -> t -> 'a mapping
                        end
                    end
                  module Sigma :
                    sig
                      type chunk = Chunk.t
                      module Chunk :
                        sig
                          type t = Chunk.t
                          type set = Heap.set
                          type 'a map = 'Heap.map
                          val hash : t -> int
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          module Map :
                            sig
                              type key = t
                              type 'a t = 'a map
                              val empty : 'a t
                              val add : key -> '-> 'a t -> 'a t
                              val mem : key -> 'a t -> bool
                              val find : key -> 'a t -> 'a
                              val findk : key -> 'a t -> key * 'a
                              val size : 'a t -> int
                              val is_empty : 'a t -> bool
                              val insert :
                                (key -> '-> '-> 'a) ->
                                key -> '-> 'a t -> 'a t
                              val change :
                                (key -> '-> 'a option -> 'a option) ->
                                key -> '-> 'a t -> 'a t
                              val map : ('-> 'b) -> 'a t -> 'b t
                              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                              val mapf :
                                (key -> '-> 'b option) -> 'a t -> 'b t
                              val mapq :
                                (key -> '-> 'a option) -> 'a t -> 'a t
                              val filter :
                                (key -> '-> bool) -> 'a t -> 'a t
                              val partition :
                                (key -> '-> bool) -> 'a t -> 'a t * 'a t
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val iter_sorted :
                                (key -> '-> unit) -> 'a t -> unit
                              val fold_sorted :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val union :
                                (key -> '-> '-> 'a) ->
                                'a t -> 'a t -> 'a t
                              val inter :
                                (key -> '-> '-> 'c) ->
                                'a t -> 'b t -> 'c t
                              val interf :
                                (key -> '-> '-> 'c option) ->
                                'a t -> 'b t -> 'c t
                              val interq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val diffq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val subset :
                                (key -> '-> '-> bool) ->
                                'a t -> 'b t -> bool
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val iterk :
                                (key -> '-> '-> unit) ->
                                'a t -> 'b t -> unit
                              val iter2 :
                                (key -> 'a option -> 'b option -> unit) ->
                                'a t -> 'b t -> unit
                              val merge :
                                (key -> 'a option -> 'b option -> 'c option) ->
                                'a t -> 'b t -> 'c t
                              type domain = set
                              val domain : 'a t -> domain
                            end
                          module Set :
                            sig
                              type elt = t
                              type t = set
                              val empty : t
                              val add : elt -> t -> t
                              val singleton : elt -> t
                              val elements : t -> elt list
                              val is_empty : t -> bool
                              val mem : elt -> t -> bool
                              val iter : (elt -> unit) -> t -> unit
                              val fold : (elt -> '-> 'a) -> t -> '-> 'a
                              val filter : (elt -> bool) -> t -> t
                              val partition : (elt -> bool) -> t -> t * t
                              val for_all : (elt -> bool) -> t -> bool
                              val exists : (elt -> bool) -> t -> bool
                              val iter_sorted : (elt -> unit) -> t -> unit
                              val fold_sorted :
                                (elt -> '-> 'a) -> t -> '-> 'a
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val subset : t -> t -> bool
                              val intersect : t -> t -> bool
                              val of_list : elt list -> t
                              type 'a mapping = 'a map
                              val mapping : (elt -> 'a) -> t -> 'a mapping
                            end
                        end
                      type domain = Chunk.Set.t
                      type t = M.Sigma.t
                      val pretty : Format.formatter -> t -> unit
                      val create : unit -> t
                      val mem : t -> chunk -> bool
                      val get : t -> chunk -> Lang.F.var
                      val value : t -> chunk -> Lang.F.term
                      val copy : t -> t
                      val join : t -> t -> Passive.t
                      val assigned :
                        pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                      val choose : t -> t -> t
                      val merge : t -> t -> t * Passive.t * Passive.t
                      val merge_list : t list -> t * Passive.t list
                      val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                      val iter2 :
                        (chunk ->
                         Lang.F.var option -> Lang.F.var option -> unit) ->
                        t -> t -> unit
                      val havoc_chunk : t -> chunk -> t
                      val havoc : t -> domain -> t
                      val havoc_any : call:bool -> t -> t
                      val remove_chunks : t -> domain -> t
                      val domain : t -> domain
                      val union : domain -> domain -> domain
                      val empty : domain
                      val writes : t sequence -> domain
                    end
                  type loc = M.loc
                  type chunk = Chunk.t
                  type sigma = Sigma.t
                  type domain = Sigma.domain
                  type segment = loc rloc
                  type state = M.state
                  val state : sigma -> state
                  val lookup : state -> Lang.F.term -> mval
                  val updates :
                    state sequence -> Lang.F.Vars.t -> update Bag.t
                  val apply : (Lang.F.term -> Lang.F.term) -> state -> state
                  val iter : (mval -> Lang.F.term -> unit) -> state -> unit
                  val pretty : Format.formatter -> loc -> unit
                  val vars : loc -> Lang.F.Vars.t
                  val occurs : Lang.F.var -> loc -> bool
                  val null : loc
                  val literal : eid:int -> Cstring.cst -> loc
                  val cvar : Cil_types.varinfo -> loc
                  val pointer_loc : Lang.F.term -> loc
                  val pointer_val : loc -> Lang.F.term
                  val field : loc -> Cil_types.fieldinfo -> loc
                  val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
                  val base_addr : loc -> loc
                  val base_offset : loc -> Lang.F.term
                  val block_length :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val cast : Ctypes.c_object sequence -> loc -> loc
                  val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
                  val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
                  val domain : Ctypes.c_object -> loc -> domain
                  val is_well_formed : sigma -> Lang.F.pred
                  val load : sigma -> Ctypes.c_object -> loc -> loc value
                  val load_init :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val copied :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val copied_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val stored :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val stored_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val assigned :
                    sigma sequence ->
                    Ctypes.c_object -> loc sloc -> equation list
                  val is_null : loc -> Lang.F.pred
                  val loc_eq : loc -> loc -> Lang.F.pred
                  val loc_lt : loc -> loc -> Lang.F.pred
                  val loc_neq : loc -> loc -> Lang.F.pred
                  val loc_leq : loc -> loc -> Lang.F.pred
                  val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
                  val valid : sigma -> acs -> segment -> Lang.F.pred
                  val frame : sigma -> Lang.F.pred list
                  val alloc : sigma -> Cil_types.varinfo list -> sigma
                  val initialized : sigma -> segment -> Lang.F.pred
                  val invalid : sigma -> segment -> Lang.F.pred
                  val scope :
                    sigma sequence ->
                    scope -> Cil_types.varinfo list -> Lang.F.pred list
                  val global : sigma -> Lang.F.term -> Lang.F.pred
                  val included : segment -> segment -> Lang.F.pred
                  val separated : segment -> segment -> Lang.F.pred
                end
              type loc = M.loc
              type nonrec value = M.loc value
              type nonrec logic = M.loc logic
              type nonrec region = M.loc region
              type nonrec result = M.loc result
              type sigma = M.Sigma.t
              type frame
              val pp_frame : Format.formatter -> frame -> unit
              val get_frame : unit -> frame
              val in_frame : frame -> ('-> 'b) -> '-> 'b
              val mem_at_frame : frame -> Clabels.c_label -> sigma
              val set_at_frame : frame -> Clabels.c_label -> sigma -> unit
              val has_at_frame : frame -> Clabels.c_label -> bool
              val mem_frame : Clabels.c_label -> sigma
              val mk_frame :
                ?kf:Cil_types.kernel_function ->
                ?result:result ->
                ?status:Lang.F.var ->
                ?formals:value Cil_datatype.Varinfo.Map.t ->
                ?labels:sigma Clabels.LabelMap.t ->
                ?descr:string -> unit -> frame
              val local : descr:string -> frame
              val frame : Cil_types.kernel_function -> frame
              type call
              val call :
                ?result:M.loc ->
                Cil_types.kernel_function -> value list -> call
              val call_pre : sigma -> call -> sigma -> frame
              val call_post : sigma -> call -> sigma sequence -> frame
              val return : unit -> Cil_types.typ
              val result : unit -> result
              val status : unit -> Lang.F.var
              val guards : frame -> Lang.F.pred list
              type env
              val mk_env :
                ?here:sigma -> ?lvars:Cil_types.logic_var list -> unit -> env
              val current : env -> sigma
              val move_at : env -> sigma -> env
              val mem_at : env -> Clabels.c_label -> sigma
              val env_at : env -> Clabels.c_label -> env
              val lval : env -> Cil_types.term_lval -> Cil_types.typ * M.loc
              val term : env -> Cil_types.term -> Lang.F.term
              val pred :
                polarity -> env -> Cil_types.predicate -> Lang.F.pred
              val call_pred :
                env ->
                Cil_types.logic_info ->
                Cil_types.logic_label list -> Lang.F.term list -> Lang.F.pred
              val region : env -> Cil_types.term -> region
              val assigned_of_lval : env -> Cil_types.lval -> region
              val assigned_of_froms : env -> Cil_types.from list -> region
              val assigned_of_assigns :
                env -> Cil_types.assigns -> region option
              val val_of_term : env -> Cil_types.term -> Lang.F.term
              val loc_of_term : env -> Cil_types.term -> loc
              val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
              val vars : region -> Lang.F.Vars.t
              val occurs : Lang.F.var -> region -> bool
              val check_assigns :
                unfold:int ->
                sigma -> written:region -> assignable:region -> Lang.F.pred
            end
          module A :
            sig
              module M :
                sig
                  val configure : unit -> WpContext.rollback
                  val configure_ia :
                    Interpreted_automata.automaton ->
                    Interpreted_automata.vertex binder
                  val datatype : string
                  val hypotheses :
                    MemoryContext.partition -> MemoryContext.partition
                  module Chunk :
                    sig
                      type t = M.Chunk.t
                      val self : string
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val pretty : Format.formatter -> t -> unit
                      val tau_of_chunk : t -> Lang.F.tau
                      val basename_of_chunk : t -> string
                      val is_framed : t -> bool
                    end
                  module Heap :
                    sig
                      type t = Chunk.t
                      type set = M.Heap.set
                      type 'a map = 'M.Heap.map
                      val hash : t -> int
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      module Map :
                        sig
                          type key = t
                          type 'a t = 'a map
                          val empty : 'a t
                          val add : key -> '-> 'a t -> 'a t
                          val mem : key -> 'a t -> bool
                          val find : key -> 'a t -> 'a
                          val findk : key -> 'a t -> key * 'a
                          val size : 'a t -> int
                          val is_empty : 'a t -> bool
                          val insert :
                            (key -> '-> '-> 'a) ->
                            key -> '-> 'a t -> 'a t
                          val change :
                            (key -> '-> 'a option -> 'a option) ->
                            key -> '-> 'a t -> 'a t
                          val map : ('-> 'b) -> 'a t -> 'b t
                          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                          val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                          val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                          val filter : (key -> '-> bool) -> 'a t -> 'a t
                          val partition :
                            (key -> '-> bool) -> 'a t -> 'a t * 'a t
                          val iter : (key -> '-> unit) -> 'a t -> unit
                          val fold :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val iter_sorted :
                            (key -> '-> unit) -> 'a t -> unit
                          val fold_sorted :
                            (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                          val union :
                            (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                          val inter :
                            (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val interf :
                            (key -> '-> '-> 'c option) ->
                            'a t -> 'b t -> 'c t
                          val interq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val diffq :
                            (key -> '-> '-> 'a option) ->
                            'a t -> 'a t -> 'a t
                          val subset :
                            (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val iterk :
                            (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                          val iter2 :
                            (key -> 'a option -> 'b option -> unit) ->
                            'a t -> 'b t -> unit
                          val merge :
                            (key -> 'a option -> 'b option -> 'c option) ->
                            'a t -> 'b t -> 'c t
                          type domain = set
                          val domain : 'a t -> domain
                        end
                      module Set :
                        sig
                          type elt = t
                          type t = set
                          val empty : t
                          val add : elt -> t -> t
                          val singleton : elt -> t
                          val elements : t -> elt list
                          val is_empty : t -> bool
                          val mem : elt -> t -> bool
                          val iter : (elt -> unit) -> t -> unit
                          val fold : (elt -> '-> 'a) -> t -> '-> 'a
                          val filter : (elt -> bool) -> t -> t
                          val partition : (elt -> bool) -> t -> t * t
                          val for_all : (elt -> bool) -> t -> bool
                          val exists : (elt -> bool) -> t -> bool
                          val iter_sorted : (elt -> unit) -> t -> unit
                          val fold_sorted :
                            (elt -> '-> 'a) -> t -> '-> 'a
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val subset : t -> t -> bool
                          val intersect : t -> t -> bool
                          val of_list : elt list -> t
                          type 'a mapping = 'a map
                          val mapping : (elt -> 'a) -> t -> 'a mapping
                        end
                    end
                  module Sigma :
                    sig
                      type chunk = Chunk.t
                      module Chunk :
                        sig
                          type t = Chunk.t
                          type set = Heap.set
                          type 'a map = 'Heap.map
                          val hash : t -> int
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          module Map :
                            sig
                              type key = t
                              type 'a t = 'a map
                              val empty : 'a t
                              val add : key -> '-> 'a t -> 'a t
                              val mem : key -> 'a t -> bool
                              val find : key -> 'a t -> 'a
                              val findk : key -> 'a t -> key * 'a
                              val size : 'a t -> int
                              val is_empty : 'a t -> bool
                              val insert :
                                (key -> '-> '-> 'a) ->
                                key -> '-> 'a t -> 'a t
                              val change :
                                (key -> '-> 'a option -> 'a option) ->
                                key -> '-> 'a t -> 'a t
                              val map : ('-> 'b) -> 'a t -> 'b t
                              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                              val mapf :
                                (key -> '-> 'b option) -> 'a t -> 'b t
                              val mapq :
                                (key -> '-> 'a option) -> 'a t -> 'a t
                              val filter :
                                (key -> '-> bool) -> 'a t -> 'a t
                              val partition :
                                (key -> '-> bool) -> 'a t -> 'a t * 'a t
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val iter_sorted :
                                (key -> '-> unit) -> 'a t -> unit
                              val fold_sorted :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val union :
                                (key -> '-> '-> 'a) ->
                                'a t -> 'a t -> 'a t
                              val inter :
                                (key -> '-> '-> 'c) ->
                                'a t -> 'b t -> 'c t
                              val interf :
                                (key -> '-> '-> 'c option) ->
                                'a t -> 'b t -> 'c t
                              val interq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val diffq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val subset :
                                (key -> '-> '-> bool) ->
                                'a t -> 'b t -> bool
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val iterk :
                                (key -> '-> '-> unit) ->
                                'a t -> 'b t -> unit
                              val iter2 :
                                (key -> 'a option -> 'b option -> unit) ->
                                'a t -> 'b t -> unit
                              val merge :
                                (key -> 'a option -> 'b option -> 'c option) ->
                                'a t -> 'b t -> 'c t
                              type domain = set
                              val domain : 'a t -> domain
                            end
                          module Set :
                            sig
                              type elt = t
                              type t = set
                              val empty : t
                              val add : elt -> t -> t
                              val singleton : elt -> t
                              val elements : t -> elt list
                              val is_empty : t -> bool
                              val mem : elt -> t -> bool
                              val iter : (elt -> unit) -> t -> unit
                              val fold : (elt -> '-> 'a) -> t -> '-> 'a
                              val filter : (elt -> bool) -> t -> t
                              val partition : (elt -> bool) -> t -> t * t
                              val for_all : (elt -> bool) -> t -> bool
                              val exists : (elt -> bool) -> t -> bool
                              val iter_sorted : (elt -> unit) -> t -> unit
                              val fold_sorted :
                                (elt -> '-> 'a) -> t -> '-> 'a
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val subset : t -> t -> bool
                              val intersect : t -> t -> bool
                              val of_list : elt list -> t
                              type 'a mapping = 'a map
                              val mapping : (elt -> 'a) -> t -> 'a mapping
                            end
                        end
                      type domain = Chunk.Set.t
                      type t = M.Sigma.t
                      val pretty : Format.formatter -> t -> unit
                      val create : unit -> t
                      val mem : t -> chunk -> bool
                      val get : t -> chunk -> Lang.F.var
                      val value : t -> chunk -> Lang.F.term
                      val copy : t -> t
                      val join : t -> t -> Passive.t
                      val assigned :
                        pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                      val choose : t -> t -> t
                      val merge : t -> t -> t * Passive.t * Passive.t
                      val merge_list : t list -> t * Passive.t list
                      val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                      val iter2 :
                        (chunk ->
                         Lang.F.var option -> Lang.F.var option -> unit) ->
                        t -> t -> unit
                      val havoc_chunk : t -> chunk -> t
                      val havoc : t -> domain -> t
                      val havoc_any : call:bool -> t -> t
                      val remove_chunks : t -> domain -> t
                      val domain : t -> domain
                      val union : domain -> domain -> domain
                      val empty : domain
                      val writes : t sequence -> domain
                    end
                  type loc = M.loc
                  type chunk = Chunk.t
                  type sigma = Sigma.t
                  type domain = Sigma.domain
                  type segment = loc rloc
                  type state = M.state
                  val state : sigma -> state
                  val lookup : state -> Lang.F.term -> mval
                  val updates :
                    state sequence -> Lang.F.Vars.t -> update Bag.t
                  val apply : (Lang.F.term -> Lang.F.term) -> state -> state
                  val iter : (mval -> Lang.F.term -> unit) -> state -> unit
                  val pretty : Format.formatter -> loc -> unit
                  val vars : loc -> Lang.F.Vars.t
                  val occurs : Lang.F.var -> loc -> bool
                  val null : loc
                  val literal : eid:int -> Cstring.cst -> loc
                  val cvar : Cil_types.varinfo -> loc
                  val pointer_loc : Lang.F.term -> loc
                  val pointer_val : loc -> Lang.F.term
                  val field : loc -> Cil_types.fieldinfo -> loc
                  val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
                  val base_addr : loc -> loc
                  val base_offset : loc -> Lang.F.term
                  val block_length :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val cast : Ctypes.c_object sequence -> loc -> loc
                  val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
                  val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
                  val domain : Ctypes.c_object -> loc -> domain
                  val is_well_formed : sigma -> Lang.F.pred
                  val load : sigma -> Ctypes.c_object -> loc -> loc value
                  val load_init :
                    sigma -> Ctypes.c_object -> loc -> Lang.F.term
                  val copied :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val copied_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> loc -> equation list
                  val stored :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val stored_init :
                    sigma sequence ->
                    Ctypes.c_object -> loc -> Lang.F.term -> equation list
                  val assigned :
                    sigma sequence ->
                    Ctypes.c_object -> loc sloc -> equation list
                  val is_null : loc -> Lang.F.pred
                  val loc_eq : loc -> loc -> Lang.F.pred
                  val loc_lt : loc -> loc -> Lang.F.pred
                  val loc_neq : loc -> loc -> Lang.F.pred
                  val loc_leq : loc -> loc -> Lang.F.pred
                  val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
                  val valid : sigma -> acs -> segment -> Lang.F.pred
                  val frame : sigma -> Lang.F.pred list
                  val alloc : sigma -> Cil_types.varinfo list -> sigma
                  val initialized : sigma -> segment -> Lang.F.pred
                  val invalid : sigma -> segment -> Lang.F.pred
                  val scope :
                    sigma sequence ->
                    scope -> Cil_types.varinfo list -> Lang.F.pred list
                  val global : sigma -> Lang.F.term -> Lang.F.pred
                  val included : segment -> segment -> Lang.F.pred
                  val separated : segment -> segment -> Lang.F.pred
                end
              module L :
                sig
                  module M :
                    sig
                      val configure : unit -> WpContext.rollback
                      val configure_ia :
                        Interpreted_automata.automaton ->
                        Interpreted_automata.vertex binder
                      val datatype : string
                      val hypotheses :
                        MemoryContext.partition -> MemoryContext.partition
                      module Chunk :
                        sig
                          type t = M.Chunk.t
                          val self : string
                          val hash : t -> int
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          val pretty : Format.formatter -> t -> unit
                          val tau_of_chunk : t -> Lang.F.tau
                          val basename_of_chunk : t -> string
                          val is_framed : t -> bool
                        end
                      module Heap :
                        sig
                          type t = Chunk.t
                          type set = M.Heap.set
                          type 'a map = 'M.Heap.map
                          val hash : t -> int
                          val equal : t -> t -> bool
                          val compare : t -> t -> int
                          module Map :
                            sig
                              type key = t
                              type 'a t = 'a map
                              val empty : 'a t
                              val add : key -> '-> 'a t -> 'a t
                              val mem : key -> 'a t -> bool
                              val find : key -> 'a t -> 'a
                              val findk : key -> 'a t -> key * 'a
                              val size : 'a t -> int
                              val is_empty : 'a t -> bool
                              val insert :
                                (key -> '-> '-> 'a) ->
                                key -> '-> 'a t -> 'a t
                              val change :
                                (key -> '-> 'a option -> 'a option) ->
                                key -> '-> 'a t -> 'a t
                              val map : ('-> 'b) -> 'a t -> 'b t
                              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                              val mapf :
                                (key -> '-> 'b option) -> 'a t -> 'b t
                              val mapq :
                                (key -> '-> 'a option) -> 'a t -> 'a t
                              val filter :
                                (key -> '-> bool) -> 'a t -> 'a t
                              val partition :
                                (key -> '-> bool) -> 'a t -> 'a t * 'a t
                              val iter : (key -> '-> unit) -> 'a t -> unit
                              val fold :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val iter_sorted :
                                (key -> '-> unit) -> 'a t -> unit
                              val fold_sorted :
                                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                              val union :
                                (key -> '-> '-> 'a) ->
                                'a t -> 'a t -> 'a t
                              val inter :
                                (key -> '-> '-> 'c) ->
                                'a t -> 'b t -> 'c t
                              val interf :
                                (key -> '-> '-> 'c option) ->
                                'a t -> 'b t -> 'c t
                              val interq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val diffq :
                                (key -> '-> '-> 'a option) ->
                                'a t -> 'a t -> 'a t
                              val subset :
                                (key -> '-> '-> bool) ->
                                'a t -> 'b t -> bool
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val iterk :
                                (key -> '-> '-> unit) ->
                                'a t -> 'b t -> unit
                              val iter2 :
                                (key -> 'a option -> 'b option -> unit) ->
                                'a t -> 'b t -> unit
                              val merge :
                                (key -> 'a option -> 'b option -> 'c option) ->
                                'a t -> 'b t -> 'c t
                              type domain = set
                              val domain : 'a t -> domain
                            end
                          module Set :
                            sig
                              type elt = t
                              type t = set
                              val empty : t
                              val add : elt -> t -> t
                              val singleton : elt -> t
                              val elements : t -> elt list
                              val is_empty : t -> bool
                              val mem : elt -> t -> bool
                              val iter : (elt -> unit) -> t -> unit
                              val fold : (elt -> '-> 'a) -> t -> '-> 'a
                              val filter : (elt -> bool) -> t -> t
                              val partition : (elt -> bool) -> t -> t * t
                              val for_all : (elt -> bool) -> t -> bool
                              val exists : (elt -> bool) -> t -> bool
                              val iter_sorted : (elt -> unit) -> t -> unit
                              val fold_sorted :
                                (elt -> '-> 'a) -> t -> '-> 'a
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val subset : t -> t -> bool
                              val intersect : t -> t -> bool
                              val of_list : elt list -> t
                              type 'a mapping = 'a map
                              val mapping : (elt -> 'a) -> t -> 'a mapping
                            end
                        end
                      module Sigma :
                        sig
                          type chunk = Chunk.t
                          module Chunk :
                            sig
                              type t = Chunk.t
                              type set = Heap.set
                              type 'a map = 'Heap.map
                              val hash : t -> int
                              val equal : t -> t -> bool
                              val compare : t -> t -> int
                              module Map :
                                sig
                                  type key = t
                                  type 'a t = 'a map
                                  val empty : 'a t
                                  val add : key -> '-> 'a t -> 'a t
                                  val mem : key -> 'a t -> bool
                                  val find : key -> 'a t -> 'a
                                  val findk : key -> 'a t -> key * 'a
                                  val size : 'a t -> int
                                  val is_empty : 'a t -> bool
                                  val insert :
                                    (key -> '-> '-> 'a) ->
                                    key -> '-> 'a t -> 'a t
                                  val change :
                                    (key -> '-> 'a option -> 'a option) ->
                                    key -> '-> 'a t -> 'a t
                                  val map : ('-> 'b) -> 'a t -> 'b t
                                  val mapi :
                                    (key -> '-> 'b) -> 'a t -> 'b t
                                  val mapf :
                                    (key -> '-> 'b option) -> 'a t -> 'b t
                                  val mapq :
                                    (key -> '-> 'a option) -> 'a t -> 'a t
                                  val filter :
                                    (key -> '-> bool) -> 'a t -> 'a t
                                  val partition :
                                    (key -> '-> bool) ->
                                    'a t -> 'a t * 'a t
                                  val iter :
                                    (key -> '-> unit) -> 'a t -> unit
                                  val fold :
                                    (key -> '-> '-> 'b) ->
                                    'a t -> '-> 'b
                                  val iter_sorted :
                                    (key -> '-> unit) -> 'a t -> unit
                                  val fold_sorted :
                                    (key -> '-> '-> 'b) ->
                                    'a t -> '-> 'b
                                  val union :
                                    (key -> '-> '-> 'a) ->
                                    'a t -> 'a t -> 'a t
                                  val inter :
                                    (key -> '-> '-> 'c) ->
                                    'a t -> 'b t -> 'c t
                                  val interf :
                                    (key -> '-> '-> 'c option) ->
                                    'a t -> 'b t -> 'c t
                                  val interq :
                                    (key -> '-> '-> 'a option) ->
                                    'a t -> 'a t -> 'a t
                                  val diffq :
                                    (key -> '-> '-> 'a option) ->
                                    'a t -> 'a t -> 'a t
                                  val subset :
                                    (key -> '-> '-> bool) ->
                                    'a t -> 'b t -> bool
                                  val equal :
                                    ('-> '-> bool) ->
                                    'a t -> 'a t -> bool
                                  val iterk :
                                    (key -> '-> '-> unit) ->
                                    'a t -> 'b t -> unit
                                  val iter2 :
                                    (key -> 'a option -> 'b option -> unit) ->
                                    'a t -> 'b t -> unit
                                  val merge :
                                    (key ->
                                     'a option -> 'b option -> 'c option) ->
                                    'a t -> 'b t -> 'c t
                                  type domain = set
                                  val domain : 'a t -> domain
                                end
                              module Set :
                                sig
                                  type elt = t
                                  type t = set
                                  val empty : t
                                  val add : elt -> t -> t
                                  val singleton : elt -> t
                                  val elements : t -> elt list
                                  val is_empty : t -> bool
                                  val mem : elt -> t -> bool
                                  val iter : (elt -> unit) -> t -> unit
                                  val fold :
                                    (elt -> '-> 'a) -> t -> '-> 'a
                                  val filter : (elt -> bool) -> t -> t
                                  val partition : (elt -> bool) -> t -> t * t
                                  val for_all : (elt -> bool) -> t -> bool
                                  val exists : (elt -> bool) -> t -> bool
                                  val iter_sorted :
                                    (elt -> unit) -> t -> unit
                                  val fold_sorted :
                                    (elt -> '-> 'a) -> t -> '-> 'a
                                  val union : t -> t -> t
                                  val inter : t -> t -> t
                                  val diff : t -> t -> t
                                  val subset : t -> t -> bool
                                  val intersect : t -> t -> bool
                                  val of_list : elt list -> t
                                  type 'a mapping = 'a map
                                  val mapping :
                                    (elt -> 'a) -> t -> 'a mapping
                                end
                            end
                          type domain = Chunk.Set.t
                          type t = M.Sigma.t
                          val pretty : Format.formatter -> t -> unit
                          val create : unit -> t
                          val mem : t -> chunk -> bool
                          val get : t -> chunk -> Lang.F.var
                          val value : t -> chunk -> Lang.F.term
                          val copy : t -> t
                          val join : t -> t -> Passive.t
                          val assigned :
                            pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                          val choose : t -> t -> t
                          val merge : t -> t -> t * Passive.t * Passive.t
                          val merge_list : t list -> t * Passive.t list
                          val iter :
                            (chunk -> Lang.F.var -> unit) -> t -> unit
                          val iter2 :
                            (chunk ->
                             Lang.F.var option -> Lang.F.var option -> unit) ->
                            t -> t -> unit
                          val havoc_chunk : t -> chunk -> t
                          val havoc : t -> domain -> t
                          val havoc_any : call:bool -> t -> t
                          val remove_chunks : t -> domain -> t
                          val domain : t -> domain
                          val union : domain -> domain -> domain
                          val empty : domain
                          val writes : t sequence -> domain
                        end
                      type loc = M.loc
                      type chunk = Chunk.t
                      type sigma = Sigma.t
                      type domain = Sigma.domain
                      type segment = loc rloc
                      type state = M.state
                      val state : sigma -> state
                      val lookup : state -> Lang.F.term -> mval
                      val updates :
                        state sequence -> Lang.F.Vars.t -> update Bag.t
                      val apply :
                        (Lang.F.term -> Lang.F.term) -> state -> state
                      val iter :
                        (mval -> Lang.F.term -> unit) -> state -> unit
                      val pretty : Format.formatter -> loc -> unit
                      val vars : loc -> Lang.F.Vars.t
                      val occurs : Lang.F.var -> loc -> bool
                      val null : loc
                      val literal : eid:int -> Cstring.cst -> loc
                      val cvar : Cil_types.varinfo -> loc
                      val pointer_loc : Lang.F.term -> loc
                      val pointer_val : loc -> Lang.F.term
                      val field : loc -> Cil_types.fieldinfo -> loc
                      val shift :
                        loc -> Ctypes.c_object -> Lang.F.term -> loc
                      val base_addr : loc -> loc
                      val base_offset : loc -> Lang.F.term
                      val block_length :
                        sigma -> Ctypes.c_object -> loc -> Lang.F.term
                      val cast : Ctypes.c_object sequence -> loc -> loc
                      val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
                      val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
                      val domain : Ctypes.c_object -> loc -> domain
                      val is_well_formed : sigma -> Lang.F.pred
                      val load : sigma -> Ctypes.c_object -> loc -> loc value
                      val load_init :
                        sigma -> Ctypes.c_object -> loc -> Lang.F.term
                      val copied :
                        sigma sequence ->
                        Ctypes.c_object -> loc -> loc -> equation list
                      val copied_init :
                        sigma sequence ->
                        Ctypes.c_object -> loc -> loc -> equation list
                      val stored :
                        sigma sequence ->
                        Ctypes.c_object ->
                        loc -> Lang.F.term -> equation list
                      val stored_init :
                        sigma sequence ->
                        Ctypes.c_object ->
                        loc -> Lang.F.term -> equation list
                      val assigned :
                        sigma sequence ->
                        Ctypes.c_object -> loc sloc -> equation list
                      val is_null : loc -> Lang.F.pred
                      val loc_eq : loc -> loc -> Lang.F.pred
                      val loc_lt : loc -> loc -> Lang.F.pred
                      val loc_neq : loc -> loc -> Lang.F.pred
                      val loc_leq : loc -> loc -> Lang.F.pred
                      val loc_diff :
                        Ctypes.c_object -> loc -> loc -> Lang.F.term
                      val valid : sigma -> acs -> segment -> Lang.F.pred
                      val frame : sigma -> Lang.F.pred list
                      val alloc : sigma -> Cil_types.varinfo list -> sigma
                      val initialized : sigma -> segment -> Lang.F.pred
                      val invalid : sigma -> segment -> Lang.F.pred
                      val scope :
                        sigma sequence ->
                        scope -> Cil_types.varinfo list -> Lang.F.pred list
                      val global : sigma -> Lang.F.term -> Lang.F.pred
                      val included : segment -> segment -> Lang.F.pred
                      val separated : segment -> segment -> Lang.F.pred
                    end
                  type loc = M.loc
                  type nonrec value = M.loc value
                  type nonrec logic = M.loc logic
                  type nonrec region = M.loc region
                  type nonrec result = M.loc result
                  type sigma = M.Sigma.t
                  type frame = L.frame
                  val pp_frame : Format.formatter -> frame -> unit
                  val get_frame : unit -> frame
                  val in_frame : frame -> ('-> 'b) -> '-> 'b
                  val mem_at_frame : frame -> Clabels.c_label -> sigma
                  val set_at_frame :
                    frame -> Clabels.c_label -> sigma -> unit
                  val has_at_frame : frame -> Clabels.c_label -> bool
                  val mem_frame : Clabels.c_label -> sigma
                  val mk_frame :
                    ?kf:Cil_types.kernel_function ->
                    ?result:result ->
                    ?status:Lang.F.var ->
                    ?formals:value Cil_datatype.Varinfo.Map.t ->
                    ?labels:sigma Clabels.LabelMap.t ->
                    ?descr:string -> unit -> frame
                  val local : descr:string -> frame
                  val frame : Cil_types.kernel_function -> frame
                  type call = L.call
                  val call :
                    ?result:M.loc ->
                    Cil_types.kernel_function -> value list -> call
                  val call_pre : sigma -> call -> sigma -> frame
                  val call_post : sigma -> call -> sigma sequence -> frame
                  val return : unit -> Cil_types.typ
                  val result : unit -> result
                  val status : unit -> Lang.F.var
                  val guards : frame -> Lang.F.pred list
                  type env = L.env
                  val mk_env :
                    ?here:sigma ->
                    ?lvars:Cil_types.logic_var list -> unit -> env
                  val current : env -> sigma
                  val move_at : env -> sigma -> env
                  val mem_at : env -> Clabels.c_label -> sigma
                  val env_at : env -> Clabels.c_label -> env
                  val lval :
                    env -> Cil_types.term_lval -> Cil_types.typ * M.loc
                  val term : env -> Cil_types.term -> Lang.F.term
                  val pred :
                    polarity -> env -> Cil_types.predicate -> Lang.F.pred
                  val call_pred :
                    env ->
                    Cil_types.logic_info ->
                    Cil_types.logic_label list ->
                    Lang.F.term list -> Lang.F.pred
                  val region : env -> Cil_types.term -> region
                  val assigned_of_lval : env -> Cil_types.lval -> region
                  val assigned_of_froms :
                    env -> Cil_types.from list -> region
                  val assigned_of_assigns :
                    env -> Cil_types.assigns -> region option
                  val val_of_term : env -> Cil_types.term -> Lang.F.term
                  val loc_of_term : env -> Cil_types.term -> loc
                  val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
                  val vars : region -> Lang.F.Vars.t
                  val occurs : Lang.F.var -> region -> bool
                  val check_assigns :
                    unfold:int ->
                    sigma ->
                    written:region -> assignable:region -> Lang.F.pred
                end
              val domain : M.loc region -> M.Heap.set
              val apply_assigns :
                M.sigma sequence -> M.loc region -> Lang.F.pred list
            end
        end
    end
  module Mstate :
    sig
      val index : Wp.Sigs.s_lval -> Wp.Lang.F.term -> Wp.Sigs.s_lval
      val field : Wp.Sigs.s_lval -> Cil_types.fieldinfo -> Wp.Sigs.s_lval
      val equal : Wp.Sigs.s_lval -> Wp.Sigs.s_lval -> bool
      type 'a model
      type state
      val create :
        (module Wp.Sigs.Model with type Sigma.t = 'a) -> 'Wp.Mstate.model
      val state : 'Wp.Mstate.model -> '-> Wp.Mstate.state
      val lookup : Wp.Mstate.state -> Wp.Lang.F.term -> Wp.Sigs.mval
      val apply :
        (Wp.Lang.F.term -> Wp.Lang.F.term) ->
        Wp.Mstate.state -> Wp.Mstate.state
      val iter :
        (Wp.Sigs.mval -> Wp.Lang.F.term -> unit) -> Wp.Mstate.state -> unit
      val updates :
        Wp.Mstate.state Wp.Sigs.sequence ->
        Wp.Lang.F.Vars.t -> Wp.Sigs.update Bag.t
    end
  module Conditions :
    sig
      val forall_intro :
        Wp.Lang.F.pred -> Wp.Lang.F.pred list * Wp.Lang.F.pred
      val exist_intro : Wp.Lang.F.pred -> Wp.Lang.F.pred
      type step = private {
        mutable id : int;
        size : int;
        vars : Wp.Lang.F.Vars.t;
        stmt : Cil_types.stmt option;
        descr : string option;
        deps : Property.t list;
        warn : Wp.Warning.Set.t;
        condition : Wp.Conditions.condition;
      }
      and condition =
          Type of Wp.Lang.F.pred
        | Have of Wp.Lang.F.pred
        | When of Wp.Lang.F.pred
        | Core of Wp.Lang.F.pred
        | Init of Wp.Lang.F.pred
        | Branch of Wp.Lang.F.pred * Wp.Conditions.sequence *
            Wp.Conditions.sequence
        | Either of Wp.Conditions.sequence list
        | State of Wp.Mstate.state
      and sequence
      type sequent = Wp.Conditions.sequence * Wp.Lang.F.pred
      val pretty :
        (Stdlib.Format.formatter -> Wp.Conditions.sequent -> unit) Stdlib.ref
      val step :
        ?descr:string ->
        ?stmt:Cil_types.stmt ->
        ?deps:Property.t list ->
        ?warn:Wp.Warning.Set.t ->
        Wp.Conditions.condition -> Wp.Conditions.step
      val update_cond :
        ?descr:string ->
        ?deps:Property.t list ->
        ?warn:Wp.Warning.Set.t ->
        Wp.Conditions.step -> Wp.Conditions.condition -> Wp.Conditions.step
      val is_true : Wp.Conditions.sequence -> bool
      val is_empty : Wp.Conditions.sequence -> bool
      val vars_hyp : Wp.Conditions.sequence -> Wp.Lang.F.Vars.t
      val vars_seq : Wp.Conditions.sequent -> Wp.Lang.F.Vars.t
      val empty : Wp.Conditions.sequence
      val trivial : Wp.Conditions.sequent
      val sequence : Wp.Conditions.step list -> Wp.Conditions.sequence
      val seq_branch :
        ?stmt:Cil_types.stmt ->
        Wp.Lang.F.pred ->
        Wp.Conditions.sequence ->
        Wp.Conditions.sequence -> Wp.Conditions.sequence
      val append :
        Wp.Conditions.sequence ->
        Wp.Conditions.sequence -> Wp.Conditions.sequence
      val concat : Wp.Conditions.sequence list -> Wp.Conditions.sequence
      val iter :
        (Wp.Conditions.step -> unit) -> Wp.Conditions.sequence -> unit
      val list : Wp.Conditions.sequence -> Wp.Conditions.step list
      val size : Wp.Conditions.sequence -> int
      val steps : Wp.Conditions.sequence -> int
      val index : Wp.Conditions.sequent -> unit
      val step_at : Wp.Conditions.sequence -> int -> Wp.Conditions.step
      val is_trivial : Wp.Conditions.sequent -> bool
      val map_condition :
        (Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
        Wp.Conditions.condition -> Wp.Conditions.condition
      val map_step :
        (Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
        Wp.Conditions.step -> Wp.Conditions.step
      val map_sequence :
        (Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
        Wp.Conditions.sequence -> Wp.Conditions.sequence
      val map_sequent :
        (Wp.Lang.F.pred -> Wp.Lang.F.pred) ->
        Wp.Conditions.sequent -> Wp.Conditions.sequent
      val insert :
        ?at:int ->
        Wp.Conditions.step -> Wp.Conditions.sequent -> Wp.Conditions.sequent
      val replace :
        at:int ->
        Wp.Conditions.step -> Wp.Conditions.sequent -> Wp.Conditions.sequent
      val replace_by_step_list :
        at:int ->
        Wp.Conditions.step list ->
        Wp.Conditions.sequent -> Wp.Conditions.sequent
      val subst :
        (Wp.Lang.F.term -> Wp.Lang.F.term) ->
        Wp.Conditions.sequent -> Wp.Conditions.sequent
      val introduction :
        Wp.Conditions.sequent -> Wp.Conditions.sequent option
      val introduction_eq : Wp.Conditions.sequent -> Wp.Conditions.sequent
      val lemma : Wp.Lang.F.pred -> Wp.Conditions.sequent
      val head : Wp.Conditions.step -> Wp.Lang.F.pred
      val have : Wp.Conditions.step -> Wp.Lang.F.pred
      val pred_cond : Wp.Conditions.condition -> Wp.Lang.F.pred
      val condition : Wp.Conditions.sequence -> Wp.Lang.F.pred
      val close : Wp.Conditions.sequent -> Wp.Lang.F.pred
      val at_closure :
        (Wp.Conditions.sequent -> Wp.Conditions.sequent) -> unit
      type bundle
      type 'a attributed =
          ?descr:string ->
          ?stmt:Cil_types.stmt ->
          ?deps:Property.t list -> ?warn:Wp.Warning.Set.t -> 'a
      val nil : Wp.Conditions.bundle
      val occurs : Wp.Lang.F.var -> Wp.Conditions.bundle -> bool
      val intersect : Wp.Lang.F.pred -> Wp.Conditions.bundle -> bool
      val merge : Wp.Conditions.bundle list -> Wp.Conditions.bundle
      val domain :
        Wp.Lang.F.pred list -> Wp.Conditions.bundle -> Wp.Conditions.bundle
      val intros :
        Wp.Lang.F.pred list -> Wp.Conditions.bundle -> Wp.Conditions.bundle
      val state :
        ?descr:string ->
        ?stmt:Cil_types.stmt ->
        Wp.Mstate.state -> Wp.Conditions.bundle -> Wp.Conditions.bundle
      val assume :
        (?init:bool ->
         ?domain:bool ->
         Wp.Lang.F.pred -> Wp.Conditions.bundle -> Wp.Conditions.bundle)
        Wp.Conditions.attributed
      val branch :
        (Wp.Lang.F.pred ->
         Wp.Conditions.bundle -> Wp.Conditions.bundle -> Wp.Conditions.bundle)
        Wp.Conditions.attributed
      val either :
        (Wp.Conditions.bundle list -> Wp.Conditions.bundle)
        Wp.Conditions.attributed
      val extract : Wp.Conditions.bundle -> Wp.Lang.F.pred list
      val bundle : Wp.Conditions.bundle -> Wp.Conditions.sequence
      val clean : Wp.Conditions.sequent -> Wp.Conditions.sequent
      val filter : Wp.Conditions.sequent -> Wp.Conditions.sequent
      val parasite : Wp.Conditions.sequent -> Wp.Conditions.sequent
      val init_filter : Wp.Conditions.sequent -> Wp.Conditions.sequent
      val simplify :
        ?solvers:Wp.Lang.simplifier list ->
        ?intros:int -> Wp.Conditions.sequent -> Wp.Conditions.sequent
      val pruning :
        ?solvers:Wp.Lang.simplifier list ->
        Wp.Conditions.sequent -> Wp.Conditions.sequent
    end
  module Filtering :
    sig
      val filter :
        polarity:bool ->
        (Wp.Lang.F.pred -> bool) -> Wp.Lang.F.pred -> Wp.Lang.F.pred
      val compute :
        ?anti:bool -> Wp.Conditions.sequent -> Wp.Conditions.sequent
    end
  module Plang :
    sig
      type scope = Qed.Engine.scope
      module Env :
        sig
          type t
          val create : unit -> t
          val copy : t -> t
          val clear : t -> unit
          val used : t -> string -> bool
          val fresh :
            t -> sanitizer:('-> string) -> ?suggest:bool -> '-> string
          val define : t -> string -> Lang.F.term -> unit
          val unfold : t -> Lang.F.term -> unit
          val shared : t -> Lang.F.term -> bool
          val shareable : t -> Lang.F.term -> bool
          val set_indexed_vars : t -> unit
          val iter : (string -> Lang.F.term -> unit) -> t -> unit
        end
      type pool
      val pool : unit -> Wp.Plang.pool
      val alloc_e :
        Wp.Plang.pool -> (Wp.Lang.F.var -> unit) -> Wp.Lang.F.term -> unit
      val alloc_p :
        Wp.Plang.pool -> (Wp.Lang.F.var -> unit) -> Wp.Lang.F.pred -> unit
      val alloc_xs :
        Wp.Plang.pool -> (Wp.Lang.F.var -> unit) -> Wp.Lang.F.Vars.t -> unit
      val alloc_domain : Wp.Plang.pool -> Wp.Lang.F.Vars.t
      val sanitizer : string -> string
      type iformat = [ `Bin | `Dec | `Hex ]
      type rformat = [ `Double | `Float | `Ratio ]
      class engine :
        object
          method bind : Lang.F.var -> string
          method callstyle : Qed.Engine.callstyle
          method datatype : Lang.ADT.t -> string
          method e_false : Qed.Engine.cmode -> string
          method e_true : Qed.Engine.cmode -> string
          method env : Env.t
          method field : Lang.Field.t -> string
          method find : Lang.F.var -> string
          method get_iformat : Wp.Plang.iformat
          method get_rformat : Wp.Plang.rformat
          method global : (unit -> unit) -> unit
          method is_atomic : Wp.Lang.F.term -> bool
          method link : Lang.Fun.t -> Qed.Engine.link
          method local : (unit -> unit) -> unit
          method lookup : Wp.Lang.F.term -> Qed.Engine.scope
          method marks : Wp.Plang.Env.t * Wp.Lang.F.marks
          method mode : Qed.Engine.mode
          method op_add : Qed.Engine.amode -> Qed.Engine.op
          method op_and : Qed.Engine.cmode -> Qed.Engine.op
          method op_div : Qed.Engine.amode -> Qed.Engine.op
          method op_eq :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_equal : Qed.Engine.cmode -> Qed.Engine.op
          method op_equiv : Qed.Engine.cmode -> Qed.Engine.op
          method op_imply : Qed.Engine.cmode -> Qed.Engine.op
          method op_leq :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_lt :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_minus : Qed.Engine.amode -> Qed.Engine.op
          method op_mod : Qed.Engine.amode -> Qed.Engine.op
          method op_mul : Qed.Engine.amode -> Qed.Engine.op
          method op_neq :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_not : Qed.Engine.cmode -> Qed.Engine.op
          method op_noteq : Qed.Engine.cmode -> Qed.Engine.op
          method op_or : Qed.Engine.cmode -> Qed.Engine.op
          method op_real_of_int : Qed.Engine.op
          method op_scope : Qed.Engine.amode -> string option
          method op_spaced : string -> bool
          method op_sub : Qed.Engine.amode -> Qed.Engine.op
          method pp_apply :
            Qed.Engine.cmode ->
            Wp.Lang.F.term -> Wp.Lang.F.term list Qed.Plib.printer
          method pp_array : Lang.F.tau Qed.Plib.printer
          method pp_array_cst :
            Format.formatter -> Lang.F.tau -> Wp.Lang.F.term -> unit
          method pp_array_get :
            Format.formatter -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
          method pp_array_set :
            Format.formatter ->
            Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
          method pp_atom : Wp.Lang.F.term Qed.Plib.printer
          method pp_conditional :
            Format.formatter ->
            Wp.Lang.F.term -> Wp.Lang.F.term -> Wp.Lang.F.term -> unit
          method pp_datatype : Lang.ADT.t -> Lang.F.tau list Qed.Plib.printer
          method pp_def_fields :
            (Lang.Field.t * Wp.Lang.F.term) list Qed.Plib.printer
          method pp_equal : Wp.Lang.F.term Qed.Plib.printer2
          method pp_exists : Lang.F.tau -> string list Qed.Plib.printer
          method pp_expr : Lang.F.tau -> Wp.Lang.F.term Qed.Plib.printer
          method pp_farray : Lang.F.tau Qed.Plib.printer2
          method pp_flow : Wp.Lang.F.term Qed.Plib.printer
          method pp_forall : Lang.F.tau -> string list Qed.Plib.printer
          method pp_fun :
            Qed.Engine.cmode ->
            Lang.Fun.t -> Wp.Lang.F.term list Qed.Plib.printer
          method pp_get_field :
            Format.formatter -> Wp.Lang.F.term -> Lang.Field.t -> unit
          method pp_imply :
            Format.formatter -> Wp.Lang.F.term list -> Wp.Lang.F.term -> unit
          method pp_int : Qed.Engine.amode -> Z.t Qed.Plib.printer
          method pp_lambda : (string * Lang.F.tau) list Qed.Plib.printer
          method pp_let :
            Format.formatter ->
            Qed.Engine.pmode -> string -> Wp.Lang.F.term -> unit
          method pp_not : Wp.Lang.F.term Qed.Plib.printer
          method pp_noteq : Wp.Lang.F.term Qed.Plib.printer2
          method pp_pred : Stdlib.Format.formatter -> Wp.Lang.F.pred -> unit
          method pp_prop : Wp.Lang.F.term Qed.Plib.printer
          method pp_real : Q.t Qed.Plib.printer
          method pp_repr : Wp.Lang.F.term Qed.Plib.printer
          method pp_sort : Wp.Lang.F.term Qed.Plib.printer
          method pp_subtau : Lang.F.tau Qed.Plib.printer
          method pp_tau : Lang.F.tau Qed.Plib.printer
          method pp_term : Wp.Lang.F.term Qed.Plib.printer
          method pp_times : Format.formatter -> Z.t -> Wp.Lang.F.term -> unit
          method pp_tvar : int Qed.Plib.printer
          method pp_var : string Qed.Plib.printer
          method sanitize : string -> string
          method sanitize_field : string -> string
          method sanitize_fun : string -> string
          method sanitize_type : string -> string
          method scope : Env.t -> (unit -> unit) -> unit
          method set_env : Env.t -> unit
          method set_iformat : Wp.Plang.iformat -> unit
          method set_rformat : Wp.Plang.rformat -> unit
          method shareable : Wp.Lang.F.term -> bool
          method shared : Wp.Lang.F.term -> bool
          method subterms :
            (Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> unit
          method t_atomic : Lang.F.tau -> bool
          method t_bool : string
          method t_int : string
          method t_prop : string
          method t_real : string
          method with_mode :
            Qed.Engine.mode -> (Qed.Engine.mode -> unit) -> unit
        end
    end
  module Pcfg :
    sig
      type env
      type label
      type value =
          Term
        | Addr of Wp.Sigs.s_lval
        | Lval of Wp.Sigs.s_lval * Wp.Pcfg.label
        | Init of Wp.Sigs.s_lval * Wp.Pcfg.label
        | Chunk of string * Wp.Pcfg.label
      val create : unit -> Wp.Pcfg.env
      val register : Wp.Conditions.sequence -> Wp.Pcfg.env
      val at : Wp.Pcfg.env -> id:int -> Wp.Pcfg.label
      val find : Wp.Pcfg.env -> Wp.Lang.F.term -> Wp.Pcfg.value
      val updates :
        Wp.Pcfg.env ->
        Wp.Pcfg.label Wp.Sigs.sequence ->
        Wp.Lang.F.Vars.t -> Wp.Sigs.update Bag.t
      val visible : Wp.Pcfg.label -> bool
      val subterms :
        Wp.Pcfg.env -> (Wp.Lang.F.term -> unit) -> Wp.Lang.F.term -> bool
      val prev : Wp.Pcfg.label -> Wp.Pcfg.label list
      val next : Wp.Pcfg.label -> Wp.Pcfg.label list
      val iter :
        (Wp.Sigs.mval -> Wp.Lang.F.term -> unit) -> Wp.Pcfg.label -> unit
      val branching : Wp.Pcfg.label -> bool
      class virtual engine :
        object
          method is_atomic_lv : Wp.Sigs.s_lval -> bool
          method pp_addr : Stdlib.Format.formatter -> Wp.Sigs.s_lval -> unit
          method virtual pp_atom :
            Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
          method pp_chunk : Stdlib.Format.formatter -> string -> unit
          method virtual pp_flow :
            Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
          method pp_host : Stdlib.Format.formatter -> Wp.Sigs.s_host -> unit
          method pp_init : Stdlib.Format.formatter -> Wp.Sigs.s_lval -> unit
          method pp_label : Stdlib.Format.formatter -> Wp.Pcfg.label -> unit
          method pp_lval : Stdlib.Format.formatter -> Wp.Sigs.s_lval -> unit
          method pp_offset :
            Stdlib.Format.formatter -> Wp.Sigs.s_offset list -> unit
          method pp_ofs : Stdlib.Format.formatter -> Wp.Sigs.s_offset -> unit
        end
    end
  module Pcond :
    sig
      val pretty : Wp.Conditions.sequent Qed.Plib.printer
      val dump : Wp.Conditions.bundle Qed.Plib.printer
      val dump_bundle :
        ?clause:string ->
        ?goal:Wp.Lang.F.pred -> Wp.Conditions.bundle Qed.Plib.printer
      val dump_sequence :
        ?clause:string ->
        ?goal:Wp.Lang.F.pred -> Wp.Conditions.sequence Qed.Plib.printer
      type env = Wp.Plang.Env.t
      val alloc_hyp :
        Wp.Plang.pool ->
        (Wp.Lang.F.var -> unit) -> Wp.Conditions.sequence -> unit
      val alloc_seq :
        Wp.Plang.pool ->
        (Wp.Lang.F.var -> unit) -> Wp.Conditions.sequent -> unit
      class engine :
        #Wp.Plang.engine ->
        object
          method mark : Wp.Lang.F.marks -> Wp.Conditions.step -> unit
          method name : Wp.Pcond.env -> Wp.Lang.F.term -> string
          method pp_block :
            clause:string -> Wp.Conditions.sequence Qed.Plib.printer
          method pp_clause : string Qed.Plib.printer
          method pp_comment : string Qed.Plib.printer
          method pp_condition :
            step:Wp.Conditions.step ->
            Wp.Conditions.condition Qed.Plib.printer
          method pp_core : Wp.Lang.F.term Qed.Plib.printer
          method pp_definition :
            Stdlib.Format.formatter -> string -> Wp.Lang.F.term -> unit
          method pp_esequent :
            Wp.Pcond.env -> Wp.Conditions.sequent Qed.Plib.printer
          method pp_goal : Wp.Lang.F.pred Qed.Plib.printer
          method pp_intro :
            step:Wp.Conditions.step ->
            clause:string -> ?dot:string -> Wp.Lang.F.pred Qed.Plib.printer
          method pp_name : string Qed.Plib.printer
          method pp_property : Property.t Qed.Plib.printer
          method pp_sequence :
            clause:string -> Wp.Conditions.sequence Qed.Plib.printer
          method pp_sequent : Wp.Conditions.sequent Qed.Plib.printer
          method pp_step : Wp.Conditions.step Qed.Plib.printer
          method pp_stmt : string Qed.Plib.printer
          method pp_warning : Wp.Warning.t Qed.Plib.printer
        end
      class state :
        object
          method bind : Lang.F.var -> string
          method callstyle : Qed.Engine.callstyle
          method clear : unit
          method datatype : Lang.ADT.t -> string
          method domain : Wp.Lang.F.Vars.t
          method e_false : Qed.Engine.cmode -> string
          method e_true : Qed.Engine.cmode -> string
          method env : Plang.Env.t
          method field : Lang.Field.t -> string
          method find : Lang.F.var -> string
          method get_iformat : Plang.iformat
          method get_rformat : Plang.rformat
          method global : (unit -> unit) -> unit
          method is_atomic : Lang.F.term -> bool
          method is_atomic_lv : Sigs.s_lval -> bool
          method label_at : id:int -> Wp.Pcfg.label
          method link : Lang.Fun.t -> Qed.Engine.link
          method local : (unit -> unit) -> unit
          method lookup : Lang.F.term -> Qed.Engine.scope
          method marks : Plang.Env.t * Lang.F.marks
          method mode : Qed.Engine.mode
          method op_add : Qed.Engine.amode -> Qed.Engine.op
          method op_and : Qed.Engine.cmode -> Qed.Engine.op
          method op_div : Qed.Engine.amode -> Qed.Engine.op
          method op_eq :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_equal : Qed.Engine.cmode -> Qed.Engine.op
          method op_equiv : Qed.Engine.cmode -> Qed.Engine.op
          method op_imply : Qed.Engine.cmode -> Qed.Engine.op
          method op_leq :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_lt :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_minus : Qed.Engine.amode -> Qed.Engine.op
          method op_mod : Qed.Engine.amode -> Qed.Engine.op
          method op_mul : Qed.Engine.amode -> Qed.Engine.op
          method op_neq :
            Qed.Engine.cmode -> Qed.Engine.amode -> Qed.Engine.op
          method op_not : Qed.Engine.cmode -> Qed.Engine.op
          method op_noteq : Qed.Engine.cmode -> Qed.Engine.op
          method op_or : Qed.Engine.cmode -> Qed.Engine.op
          method op_real_of_int : Qed.Engine.op
          method op_scope : Qed.Engine.amode -> string option
          method op_spaced : string -> bool
          method op_sub : Qed.Engine.amode -> Qed.Engine.op
          method pp_addr : Format.formatter -> Sigs.s_lval -> unit
          method pp_apply :
            Qed.Engine.cmode ->
            Lang.F.term -> Lang.F.term list Qed.Plib.printer
          method pp_array : Lang.F.tau Qed.Plib.printer
          method pp_array_cst :
            Format.formatter -> Lang.F.tau -> Lang.F.term -> unit
          method pp_array_get :
            Format.formatter -> Lang.F.term -> Lang.F.term -> unit
          method pp_array_set :
            Format.formatter ->
            Lang.F.term -> Lang.F.term -> Lang.F.term -> unit
          method pp_at : Stdlib.Format.formatter -> Wp.Pcfg.label -> unit
          method pp_atom : Lang.F.term Qed.Plib.printer
          method pp_chunk : Format.formatter -> string -> unit
          method pp_conditional :
            Format.formatter ->
            Lang.F.term -> Lang.F.term -> Lang.F.term -> unit
          method pp_datatype : Lang.ADT.t -> Lang.F.tau list Qed.Plib.printer
          method pp_def_fields :
            (Lang.Field.t * Lang.F.term) list Qed.Plib.printer
          method pp_equal : Lang.F.term Qed.Plib.printer2
          method pp_exists : Lang.F.tau -> string list Qed.Plib.printer
          method pp_expr : Lang.F.tau -> Lang.F.term Qed.Plib.printer
          method pp_farray : Lang.F.tau Qed.Plib.printer2
          method pp_flow : Lang.F.term Qed.Plib.printer
          method pp_forall : Lang.F.tau -> string list Qed.Plib.printer
          method pp_fun :
            Qed.Engine.cmode ->
            Lang.Fun.t -> Lang.F.term list Qed.Plib.printer
          method pp_get_field :
            Format.formatter -> Lang.F.term -> Lang.Field.t -> unit
          method pp_host : Format.formatter -> Sigs.s_host -> unit
          method pp_imply :
            Format.formatter -> Lang.F.term list -> Lang.F.term -> unit
          method pp_init : Format.formatter -> Sigs.s_lval -> unit
          method pp_int : Qed.Engine.amode -> Z.t Qed.Plib.printer
          method pp_label : Format.formatter -> Pcfg.label -> unit
          method pp_lambda : (string * Lang.F.tau) list Qed.Plib.printer
          method pp_let :
            Format.formatter ->
            Qed.Engine.pmode -> string -> Lang.F.term -> unit
          method pp_lval : Format.formatter -> Sigs.s_lval -> unit
          method pp_not : Lang.F.term Qed.Plib.printer
          method pp_noteq : Lang.F.term Qed.Plib.printer2
          method pp_offset : Format.formatter -> Sigs.s_offset list -> unit
          method pp_ofs : Format.formatter -> Sigs.s_offset -> unit
          method pp_pred : Format.formatter -> Lang.F.pred -> unit
          method pp_prop : Lang.F.term Qed.Plib.printer
          method pp_real : Q.t Qed.Plib.printer
          method pp_repr : Lang.F.term Qed.Plib.printer
          method pp_sort : Lang.F.term Qed.Plib.printer
          method pp_subtau : Lang.F.tau Qed.Plib.printer
          method pp_tau : Lang.F.tau Qed.Plib.printer
          method pp_term : Lang.F.term Qed.Plib.printer
          method pp_times : Format.formatter -> Z.t -> Lang.F.term -> unit
          method pp_tvar : int Qed.Plib.printer
          method pp_update :
            Wp.Pcfg.label ->
            Stdlib.Format.formatter -> Wp.Sigs.update -> unit
          method pp_value : Stdlib.Format.formatter -> Wp.Lang.F.term -> unit
          method pp_var : string Qed.Plib.printer
          method sanitize : string -> string
          method sanitize_field : string -> string
          method sanitize_fun : string -> string
          method sanitize_type : string -> string
          method scope : Plang.Env.t -> (unit -> unit) -> unit
          method set_domain : Wp.Lang.F.Vars.t -> unit
          method set_env : Plang.Env.t -> unit
          method set_iformat : Plang.iformat -> unit
          method set_rformat : Plang.rformat -> unit
          method set_sequence : Wp.Conditions.sequence -> unit
          method shareable : Lang.F.term -> bool
          method shared : Lang.F.term -> bool
          method subterms : (Lang.F.term -> unit) -> Lang.F.term -> unit
          method t_atomic : Lang.F.tau -> bool
          method t_bool : string
          method t_int : string
          method t_prop : string
          method t_real : string
          method updates :
            Wp.Pcfg.label Wp.Sigs.sequence -> Wp.Sigs.update Bag.t
          method with_mode :
            Qed.Engine.mode -> (Qed.Engine.mode -> unit) -> unit
        end
      class seqengine :
        #Wp.Pcond.state ->
        object
          method get_state : bool
          method mark : Lang.F.marks -> Conditions.step -> unit
          method name : env -> Lang.F.term -> string
          method pp_block :
            clause:string -> Conditions.sequence Qed.Plib.printer
          method pp_clause : string Qed.Plib.printer
          method pp_comment : string Qed.Plib.printer
          method pp_condition :
            step:Conditions.step -> Conditions.condition Qed.Plib.printer
          method pp_core : Lang.F.term Qed.Plib.printer
          method pp_definition :
            Format.formatter -> string -> Lang.F.term -> unit
          method pp_esequent : env -> Conditions.sequent Qed.Plib.printer
          method pp_goal : Lang.F.pred Qed.Plib.printer
          method pp_intro :
            step:Conditions.step ->
            clause:string -> ?dot:string -> Lang.F.pred Qed.Plib.printer
          method pp_name : string Qed.Plib.printer
          method pp_property : Property.t Qed.Plib.printer
          method pp_sequence :
            clause:string -> Conditions.sequence Qed.Plib.printer
          method pp_sequent : Conditions.sequent Qed.Plib.printer
          method pp_step : Conditions.step Qed.Plib.printer
          method pp_stmt : string Qed.Plib.printer
          method pp_warning : Warning.t Qed.Plib.printer
          method set_goal : Wp.Lang.F.pred -> unit
          method set_sequence : Wp.Conditions.sequence -> unit
          method set_sequent : Wp.Conditions.sequent -> unit
          method set_state : bool -> unit
        end
    end
  module CodeSemantics :
    sig
      module Make :
        functor (M : Sigs.Model->
          sig
            module M :
              sig
                val configure : unit -> WpContext.rollback
                val configure_ia :
                  Interpreted_automata.automaton ->
                  Interpreted_automata.vertex Sigs.binder
                val datatype : string
                val hypotheses :
                  MemoryContext.partition -> MemoryContext.partition
                module Chunk :
                  sig
                    type t = M.Chunk.t
                    val self : string
                    val hash : t -> int
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val pretty : Format.formatter -> t -> unit
                    val tau_of_chunk : t -> Lang.F.tau
                    val basename_of_chunk : t -> string
                    val is_framed : t -> bool
                  end
                module Heap :
                  sig
                    type t = Chunk.t
                    type set = M.Heap.set
                    type 'a map = 'M.Heap.map
                    val hash : t -> int
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    module Map :
                      sig
                        type key = t
                        type 'a t = 'a map
                        val empty : 'a t
                        val add : key -> '-> 'a t -> 'a t
                        val mem : key -> 'a t -> bool
                        val find : key -> 'a t -> 'a
                        val findk : key -> 'a t -> key * 'a
                        val size : 'a t -> int
                        val is_empty : 'a t -> bool
                        val insert :
                          (key -> '-> '-> 'a) ->
                          key -> '-> 'a t -> 'a t
                        val change :
                          (key -> '-> 'a option -> 'a option) ->
                          key -> '-> 'a t -> 'a t
                        val map : ('-> 'b) -> 'a t -> 'b t
                        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                        val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                        val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                        val filter : (key -> '-> bool) -> 'a t -> 'a t
                        val partition :
                          (key -> '-> bool) -> 'a t -> 'a t * 'a t
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                        val fold_sorted :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val union :
                          (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                        val inter :
                          (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                        val interf :
                          (key -> '-> '-> 'c option) ->
                          'a t -> 'b t -> 'c t
                        val interq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val diffq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val subset :
                          (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val iterk :
                          (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                        val iter2 :
                          (key -> 'a option -> 'b option -> unit) ->
                          'a t -> 'b t -> unit
                        val merge :
                          (key -> 'a option -> 'b option -> 'c option) ->
                          'a t -> 'b t -> 'c t
                        type domain = set
                        val domain : 'a t -> domain
                      end
                    module Set :
                      sig
                        type elt = t
                        type t = set
                        val empty : t
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val elements : t -> elt list
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val iter_sorted : (elt -> unit) -> t -> unit
                        val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val subset : t -> t -> bool
                        val intersect : t -> t -> bool
                        val of_list : elt list -> t
                        type 'a mapping = 'a map
                        val mapping : (elt -> 'a) -> t -> 'a mapping
                      end
                  end
                module Sigma :
                  sig
                    type chunk = Chunk.t
                    module Chunk :
                      sig
                        type t = Chunk.t
                        type set = Heap.set
                        type 'a map = 'Heap.map
                        val hash : t -> int
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        module Map :
                          sig
                            type key = t
                            type 'a t = 'a map
                            val empty : 'a t
                            val add : key -> '-> 'a t -> 'a t
                            val mem : key -> 'a t -> bool
                            val find : key -> 'a t -> 'a
                            val findk : key -> 'a t -> key * 'a
                            val size : 'a t -> int
                            val is_empty : 'a t -> bool
                            val insert :
                              (key -> '-> '-> 'a) ->
                              key -> '-> 'a t -> 'a t
                            val change :
                              (key -> '-> 'a option -> 'a option) ->
                              key -> '-> 'a t -> 'a t
                            val map : ('-> 'b) -> 'a t -> 'b t
                            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                            val mapf :
                              (key -> '-> 'b option) -> 'a t -> 'b t
                            val mapq :
                              (key -> '-> 'a option) -> 'a t -> 'a t
                            val filter : (key -> '-> bool) -> 'a t -> 'a t
                            val partition :
                              (key -> '-> bool) -> 'a t -> 'a t * 'a t
                            val iter : (key -> '-> unit) -> 'a t -> unit
                            val fold :
                              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                            val iter_sorted :
                              (key -> '-> unit) -> 'a t -> unit
                            val fold_sorted :
                              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                            val union :
                              (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                            val inter :
                              (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                            val interf :
                              (key -> '-> '-> 'c option) ->
                              'a t -> 'b t -> 'c t
                            val interq :
                              (key -> '-> '-> 'a option) ->
                              'a t -> 'a t -> 'a t
                            val diffq :
                              (key -> '-> '-> 'a option) ->
                              'a t -> 'a t -> 'a t
                            val subset :
                              (key -> '-> '-> bool) ->
                              'a t -> 'b t -> bool
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val iterk :
                              (key -> '-> '-> unit) ->
                              'a t -> 'b t -> unit
                            val iter2 :
                              (key -> 'a option -> 'b option -> unit) ->
                              'a t -> 'b t -> unit
                            val merge :
                              (key -> 'a option -> 'b option -> 'c option) ->
                              'a t -> 'b t -> 'c t
                            type domain = set
                            val domain : 'a t -> domain
                          end
                        module Set :
                          sig
                            type elt = t
                            type t = set
                            val empty : t
                            val add : elt -> t -> t
                            val singleton : elt -> t
                            val elements : t -> elt list
                            val is_empty : t -> bool
                            val mem : elt -> t -> bool
                            val iter : (elt -> unit) -> t -> unit
                            val fold : (elt -> '-> 'a) -> t -> '-> 'a
                            val filter : (elt -> bool) -> t -> t
                            val partition : (elt -> bool) -> t -> t * t
                            val for_all : (elt -> bool) -> t -> bool
                            val exists : (elt -> bool) -> t -> bool
                            val iter_sorted : (elt -> unit) -> t -> unit
                            val fold_sorted :
                              (elt -> '-> 'a) -> t -> '-> 'a
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val subset : t -> t -> bool
                            val intersect : t -> t -> bool
                            val of_list : elt list -> t
                            type 'a mapping = 'a map
                            val mapping : (elt -> 'a) -> t -> 'a mapping
                          end
                      end
                    type domain = Chunk.Set.t
                    type t = M.Sigma.t
                    val pretty : Format.formatter -> t -> unit
                    val create : unit -> t
                    val mem : t -> chunk -> bool
                    val get : t -> chunk -> Lang.F.var
                    val value : t -> chunk -> Lang.F.term
                    val copy : t -> t
                    val join : t -> t -> Passive.t
                    val assigned :
                      pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                    val choose : t -> t -> t
                    val merge : t -> t -> t * Passive.t * Passive.t
                    val merge_list : t list -> t * Passive.t list
                    val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                    val iter2 :
                      (chunk ->
                       Lang.F.var option -> Lang.F.var option -> unit) ->
                      t -> t -> unit
                    val havoc_chunk : t -> chunk -> t
                    val havoc : t -> domain -> t
                    val havoc_any : call:bool -> t -> t
                    val remove_chunks : t -> domain -> t
                    val domain : t -> domain
                    val union : domain -> domain -> domain
                    val empty : domain
                    val writes : t Sigs.sequence -> domain
                  end
                type loc = M.loc
                type chunk = Chunk.t
                type sigma = Sigma.t
                type domain = Sigma.domain
                type segment = loc Sigs.rloc
                type state = M.state
                val state : sigma -> state
                val lookup : state -> Lang.F.term -> Sigs.mval
                val updates :
                  state Sigs.sequence -> Lang.F.Vars.t -> Sigs.update Bag.t
                val apply : (Lang.F.term -> Lang.F.term) -> state -> state
                val iter :
                  (Sigs.mval -> Lang.F.term -> unit) -> state -> unit
                val pretty : Format.formatter -> loc -> unit
                val vars : loc -> Lang.F.Vars.t
                val occurs : Lang.F.var -> loc -> bool
                val null : loc
                val literal : eid:int -> Cstring.cst -> loc
                val cvar : Cil_types.varinfo -> loc
                val pointer_loc : Lang.F.term -> loc
                val pointer_val : loc -> Lang.F.term
                val field : loc -> Cil_types.fieldinfo -> loc
                val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
                val base_addr : loc -> loc
                val base_offset : loc -> Lang.F.term
                val block_length :
                  sigma -> Ctypes.c_object -> loc -> Lang.F.term
                val cast : Ctypes.c_object Sigs.sequence -> loc -> loc
                val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
                val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
                val domain : Ctypes.c_object -> loc -> domain
                val is_well_formed : sigma -> Lang.F.pred
                val load : sigma -> Ctypes.c_object -> loc -> loc Sigs.value
                val load_init :
                  sigma -> Ctypes.c_object -> loc -> Lang.F.term
                val copied :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> loc -> Sigs.equation list
                val copied_init :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> loc -> Sigs.equation list
                val stored :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
                val stored_init :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
                val assigned :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc Sigs.sloc -> Sigs.equation list
                val is_null : loc -> Lang.F.pred
                val loc_eq : loc -> loc -> Lang.F.pred
                val loc_lt : loc -> loc -> Lang.F.pred
                val loc_neq : loc -> loc -> Lang.F.pred
                val loc_leq : loc -> loc -> Lang.F.pred
                val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
                val valid : sigma -> Sigs.acs -> segment -> Lang.F.pred
                val frame : sigma -> Lang.F.pred list
                val alloc : sigma -> Cil_types.varinfo list -> sigma
                val initialized : sigma -> segment -> Lang.F.pred
                val invalid : sigma -> segment -> Lang.F.pred
                val scope :
                  sigma Sigs.sequence ->
                  Sigs.scope -> Cil_types.varinfo list -> Lang.F.pred list
                val global : sigma -> Lang.F.term -> Lang.F.pred
                val included : segment -> segment -> Lang.F.pred
                val separated : segment -> segment -> Lang.F.pred
              end
            type loc = M.loc
            type nonrec value = loc Sigs.value
            type nonrec result = loc Sigs.result
            type sigma = M.Sigma.t
            val pp_value : Format.formatter -> value -> unit
            val cval : value -> Lang.F.term
            val cloc : value -> loc
            val cast : Cil_types.typ -> Cil_types.typ -> value -> value
            val equal_typ : Cil_types.typ -> value -> value -> Lang.F.pred
            val not_equal_typ :
              Cil_types.typ -> value -> value -> Lang.F.pred
            val equal_obj : Ctypes.c_object -> value -> value -> Lang.F.pred
            val not_equal_obj :
              Ctypes.c_object -> value -> value -> Lang.F.pred
            val exp : sigma -> Cil_types.exp -> value
            val cond : sigma -> Cil_types.exp -> Lang.F.pred
            val lval : sigma -> Cil_types.lval -> loc
            val call : sigma -> Cil_types.exp -> loc
            val instance_of : loc -> Cil_types.kernel_function -> Lang.F.pred
            val loc_of_exp : sigma -> Cil_types.exp -> loc
            val val_of_exp : sigma -> Cil_types.exp -> Lang.F.term
            val result : sigma -> Cil_types.typ -> result -> Lang.F.term
            val return :
              sigma -> Cil_types.typ -> Cil_types.exp -> Lang.F.term
            val is_zero : sigma -> Ctypes.c_object -> loc -> Lang.F.pred
            val is_exp_range :
              sigma ->
              loc ->
              Ctypes.c_object ->
              Lang.F.term -> Lang.F.term -> value option -> Lang.F.pred
            val unchanged :
              M.sigma -> M.sigma -> Cil_types.varinfo -> Lang.F.pred
            type warned_hyp = Warning.Set.t * (Lang.F.pred * Lang.F.pred)
            val init :
              sigma:M.sigma ->
              Cil_types.varinfo -> Cil_types.init option -> warned_hyp list
          end
    end
  module LogicCompiler :
    sig
      type polarity = [ `Negative | `NoPolarity | `Positive ]
      module Make :
        functor (M : Sigs.Model->
          sig
            type value = M.loc Wp.Sigs.value
            type logic = M.loc Wp.Sigs.logic
            type result = M.loc Wp.Sigs.result
            type sigma = M.Sigma.t
            type chunk = M.Chunk.t
            type call
            type frame
            val pp_frame :
              Stdlib.Format.formatter -> Wp.LogicCompiler.Make.frame -> unit
            val local : descr:string -> Wp.LogicCompiler.Make.frame
            val frame :
              Cil_types.kernel_function -> Wp.LogicCompiler.Make.frame
            val call :
              ?result:M.loc ->
              Cil_types.kernel_function ->
              Wp.LogicCompiler.Make.value list -> Wp.LogicCompiler.Make.call
            val call_pre :
              Wp.LogicCompiler.Make.sigma ->
              Wp.LogicCompiler.Make.call ->
              Wp.LogicCompiler.Make.sigma -> Wp.LogicCompiler.Make.frame
            val call_post :
              Wp.LogicCompiler.Make.sigma ->
              Wp.LogicCompiler.Make.call ->
              Wp.LogicCompiler.Make.sigma Wp.Sigs.sequence ->
              Wp.LogicCompiler.Make.frame
            val mk_frame :
              ?kf:Cil_types.kernel_function ->
              ?result:Wp.LogicCompiler.Make.result ->
              ?status:Wp.Lang.F.var ->
              ?formals:Wp.LogicCompiler.Make.value Cil_datatype.Varinfo.Map.t ->
              ?labels:Wp.LogicCompiler.Make.sigma Wp.Clabels.LabelMap.t ->
              ?descr:string -> unit -> Wp.LogicCompiler.Make.frame
            val formal :
              Cil_types.varinfo -> Wp.LogicCompiler.Make.value option
            val return : unit -> Cil_types.typ
            val result : unit -> Wp.LogicCompiler.Make.result
            val status : unit -> Wp.Lang.F.var
            val trigger : Wp.Definitions.trigger -> unit
            val guards : Wp.LogicCompiler.Make.frame -> Wp.Lang.F.pred list
            val mem_frame : Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma
            val has_at_frame :
              Wp.LogicCompiler.Make.frame -> Wp.Clabels.c_label -> bool
            val mem_at_frame :
              Wp.LogicCompiler.Make.frame ->
              Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma
            val set_at_frame :
              Wp.LogicCompiler.Make.frame ->
              Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma -> unit
            val in_frame :
              Wp.LogicCompiler.Make.frame -> ('-> 'b) -> '-> 'b
            val get_frame : unit -> Wp.LogicCompiler.Make.frame
            type env
            val mk_env :
              ?here:Wp.LogicCompiler.Make.sigma ->
              ?lvars:Cil_datatype.Logic_var.t list ->
              unit -> Wp.LogicCompiler.Make.env
            val current :
              Wp.LogicCompiler.Make.env -> Wp.LogicCompiler.Make.sigma
            val move_at :
              Wp.LogicCompiler.Make.env ->
              Wp.LogicCompiler.Make.sigma -> Wp.LogicCompiler.Make.env
            val env_at :
              Wp.LogicCompiler.Make.env ->
              Wp.Clabels.c_label -> Wp.LogicCompiler.Make.env
            val mem_at :
              Wp.LogicCompiler.Make.env ->
              Wp.Clabels.c_label -> Wp.LogicCompiler.Make.sigma
            val env_let :
              Wp.LogicCompiler.Make.env ->
              Cil_types.logic_var ->
              Wp.LogicCompiler.Make.logic -> Wp.LogicCompiler.Make.env
            val env_letp :
              Wp.LogicCompiler.Make.env ->
              Cil_types.logic_var ->
              Wp.Lang.F.pred -> Wp.LogicCompiler.Make.env
            val env_letval :
              Wp.LogicCompiler.Make.env ->
              Cil_types.logic_var ->
              Wp.LogicCompiler.Make.value -> Wp.LogicCompiler.Make.env
            val term :
              Wp.LogicCompiler.Make.env -> Cil_types.term -> Wp.Lang.F.term
            val pred :
              Wp.LogicCompiler.polarity ->
              Wp.LogicCompiler.Make.env ->
              Cil_types.predicate -> Wp.Lang.F.pred
            val logic :
              Wp.LogicCompiler.Make.env ->
              Cil_types.term -> Wp.LogicCompiler.Make.logic
            val region :
              Wp.LogicCompiler.Make.env ->
              Cil_types.term -> M.loc Wp.Sigs.region
            val bootstrap_term :
              (Wp.LogicCompiler.Make.env -> Cil_types.term -> Wp.Lang.F.term) ->
              unit
            val bootstrap_pred :
              (Wp.LogicCompiler.polarity ->
               Wp.LogicCompiler.Make.env ->
               Cil_types.predicate -> Wp.Lang.F.pred) ->
              unit
            val bootstrap_logic :
              (Wp.LogicCompiler.Make.env ->
               Cil_types.term -> Wp.LogicCompiler.Make.logic) ->
              unit
            val bootstrap_region :
              (Wp.LogicCompiler.Make.env ->
               Cil_types.term -> M.loc Wp.Sigs.region) ->
              unit
            val call_fun :
              Wp.LogicCompiler.Make.env ->
              Wp.Lang.F.tau ->
              Cil_types.logic_info ->
              Cil_types.logic_label list ->
              Wp.Lang.F.term list -> Wp.Lang.F.term
            val call_pred :
              Wp.LogicCompiler.Make.env ->
              Cil_types.logic_info ->
              Cil_types.logic_label list ->
              Wp.Lang.F.term list -> Wp.Lang.F.pred
            val logic_var :
              Wp.LogicCompiler.Make.env ->
              Cil_types.logic_var -> Wp.LogicCompiler.Make.logic
            val logic_info :
              Wp.LogicCompiler.Make.env ->
              Cil_types.logic_info -> Wp.Lang.F.pred option
            val has_ltype :
              Cil_types.logic_type -> Wp.Lang.F.term -> Wp.Lang.F.pred
            val lemma : Wp.LogicUsage.logic_lemma -> Wp.Definitions.dlemma
          end
    end
  module LogicSemantics :
    sig
      module Make :
        functor (M : Sigs.Model->
          sig
            module M :
              sig
                val configure : unit -> WpContext.rollback
                val configure_ia :
                  Interpreted_automata.automaton ->
                  Interpreted_automata.vertex Sigs.binder
                val datatype : string
                val hypotheses :
                  MemoryContext.partition -> MemoryContext.partition
                module Chunk :
                  sig
                    type t = M.Chunk.t
                    val self : string
                    val hash : t -> int
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val pretty : Format.formatter -> t -> unit
                    val tau_of_chunk : t -> Lang.F.tau
                    val basename_of_chunk : t -> string
                    val is_framed : t -> bool
                  end
                module Heap :
                  sig
                    type t = Chunk.t
                    type set = M.Heap.set
                    type 'a map = 'M.Heap.map
                    val hash : t -> int
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    module Map :
                      sig
                        type key = t
                        type 'a t = 'a map
                        val empty : 'a t
                        val add : key -> '-> 'a t -> 'a t
                        val mem : key -> 'a t -> bool
                        val find : key -> 'a t -> 'a
                        val findk : key -> 'a t -> key * 'a
                        val size : 'a t -> int
                        val is_empty : 'a t -> bool
                        val insert :
                          (key -> '-> '-> 'a) ->
                          key -> '-> 'a t -> 'a t
                        val change :
                          (key -> '-> 'a option -> 'a option) ->
                          key -> '-> 'a t -> 'a t
                        val map : ('-> 'b) -> 'a t -> 'b t
                        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                        val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                        val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                        val filter : (key -> '-> bool) -> 'a t -> 'a t
                        val partition :
                          (key -> '-> bool) -> 'a t -> 'a t * 'a t
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                        val fold_sorted :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val union :
                          (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                        val inter :
                          (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                        val interf :
                          (key -> '-> '-> 'c option) ->
                          'a t -> 'b t -> 'c t
                        val interq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val diffq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val subset :
                          (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val iterk :
                          (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                        val iter2 :
                          (key -> 'a option -> 'b option -> unit) ->
                          'a t -> 'b t -> unit
                        val merge :
                          (key -> 'a option -> 'b option -> 'c option) ->
                          'a t -> 'b t -> 'c t
                        type domain = set
                        val domain : 'a t -> domain
                      end
                    module Set :
                      sig
                        type elt = t
                        type t = set
                        val empty : t
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val elements : t -> elt list
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val iter_sorted : (elt -> unit) -> t -> unit
                        val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val subset : t -> t -> bool
                        val intersect : t -> t -> bool
                        val of_list : elt list -> t
                        type 'a mapping = 'a map
                        val mapping : (elt -> 'a) -> t -> 'a mapping
                      end
                  end
                module Sigma :
                  sig
                    type chunk = Chunk.t
                    module Chunk :
                      sig
                        type t = Chunk.t
                        type set = Heap.set
                        type 'a map = 'Heap.map
                        val hash : t -> int
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        module Map :
                          sig
                            type key = t
                            type 'a t = 'a map
                            val empty : 'a t
                            val add : key -> '-> 'a t -> 'a t
                            val mem : key -> 'a t -> bool
                            val find : key -> 'a t -> 'a
                            val findk : key -> 'a t -> key * 'a
                            val size : 'a t -> int
                            val is_empty : 'a t -> bool
                            val insert :
                              (key -> '-> '-> 'a) ->
                              key -> '-> 'a t -> 'a t
                            val change :
                              (key -> '-> 'a option -> 'a option) ->
                              key -> '-> 'a t -> 'a t
                            val map : ('-> 'b) -> 'a t -> 'b t
                            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                            val mapf :
                              (key -> '-> 'b option) -> 'a t -> 'b t
                            val mapq :
                              (key -> '-> 'a option) -> 'a t -> 'a t
                            val filter : (key -> '-> bool) -> 'a t -> 'a t
                            val partition :
                              (key -> '-> bool) -> 'a t -> 'a t * 'a t
                            val iter : (key -> '-> unit) -> 'a t -> unit
                            val fold :
                              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                            val iter_sorted :
                              (key -> '-> unit) -> 'a t -> unit
                            val fold_sorted :
                              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                            val union :
                              (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                            val inter :
                              (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                            val interf :
                              (key -> '-> '-> 'c option) ->
                              'a t -> 'b t -> 'c t
                            val interq :
                              (key -> '-> '-> 'a option) ->
                              'a t -> 'a t -> 'a t
                            val diffq :
                              (key -> '-> '-> 'a option) ->
                              'a t -> 'a t -> 'a t
                            val subset :
                              (key -> '-> '-> bool) ->
                              'a t -> 'b t -> bool
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val iterk :
                              (key -> '-> '-> unit) ->
                              'a t -> 'b t -> unit
                            val iter2 :
                              (key -> 'a option -> 'b option -> unit) ->
                              'a t -> 'b t -> unit
                            val merge :
                              (key -> 'a option -> 'b option -> 'c option) ->
                              'a t -> 'b t -> 'c t
                            type domain = set
                            val domain : 'a t -> domain
                          end
                        module Set :
                          sig
                            type elt = t
                            type t = set
                            val empty : t
                            val add : elt -> t -> t
                            val singleton : elt -> t
                            val elements : t -> elt list
                            val is_empty : t -> bool
                            val mem : elt -> t -> bool
                            val iter : (elt -> unit) -> t -> unit
                            val fold : (elt -> '-> 'a) -> t -> '-> 'a
                            val filter : (elt -> bool) -> t -> t
                            val partition : (elt -> bool) -> t -> t * t
                            val for_all : (elt -> bool) -> t -> bool
                            val exists : (elt -> bool) -> t -> bool
                            val iter_sorted : (elt -> unit) -> t -> unit
                            val fold_sorted :
                              (elt -> '-> 'a) -> t -> '-> 'a
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val subset : t -> t -> bool
                            val intersect : t -> t -> bool
                            val of_list : elt list -> t
                            type 'a mapping = 'a map
                            val mapping : (elt -> 'a) -> t -> 'a mapping
                          end
                      end
                    type domain = Chunk.Set.t
                    type t = M.Sigma.t
                    val pretty : Format.formatter -> t -> unit
                    val create : unit -> t
                    val mem : t -> chunk -> bool
                    val get : t -> chunk -> Lang.F.var
                    val value : t -> chunk -> Lang.F.term
                    val copy : t -> t
                    val join : t -> t -> Passive.t
                    val assigned :
                      pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                    val choose : t -> t -> t
                    val merge : t -> t -> t * Passive.t * Passive.t
                    val merge_list : t list -> t * Passive.t list
                    val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                    val iter2 :
                      (chunk ->
                       Lang.F.var option -> Lang.F.var option -> unit) ->
                      t -> t -> unit
                    val havoc_chunk : t -> chunk -> t
                    val havoc : t -> domain -> t
                    val havoc_any : call:bool -> t -> t
                    val remove_chunks : t -> domain -> t
                    val domain : t -> domain
                    val union : domain -> domain -> domain
                    val empty : domain
                    val writes : t Sigs.sequence -> domain
                  end
                type loc = M.loc
                type chunk = Chunk.t
                type sigma = Sigma.t
                type domain = Sigma.domain
                type segment = loc Sigs.rloc
                type state = M.state
                val state : sigma -> state
                val lookup : state -> Lang.F.term -> Sigs.mval
                val updates :
                  state Sigs.sequence -> Lang.F.Vars.t -> Sigs.update Bag.t
                val apply : (Lang.F.term -> Lang.F.term) -> state -> state
                val iter :
                  (Sigs.mval -> Lang.F.term -> unit) -> state -> unit
                val pretty : Format.formatter -> loc -> unit
                val vars : loc -> Lang.F.Vars.t
                val occurs : Lang.F.var -> loc -> bool
                val null : loc
                val literal : eid:int -> Cstring.cst -> loc
                val cvar : Cil_types.varinfo -> loc
                val pointer_loc : Lang.F.term -> loc
                val pointer_val : loc -> Lang.F.term
                val field : loc -> Cil_types.fieldinfo -> loc
                val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
                val base_addr : loc -> loc
                val base_offset : loc -> Lang.F.term
                val block_length :
                  sigma -> Ctypes.c_object -> loc -> Lang.F.term
                val cast : Ctypes.c_object Sigs.sequence -> loc -> loc
                val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
                val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
                val domain : Ctypes.c_object -> loc -> domain
                val is_well_formed : sigma -> Lang.F.pred
                val load : sigma -> Ctypes.c_object -> loc -> loc Sigs.value
                val load_init :
                  sigma -> Ctypes.c_object -> loc -> Lang.F.term
                val copied :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> loc -> Sigs.equation list
                val copied_init :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> loc -> Sigs.equation list
                val stored :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
                val stored_init :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
                val assigned :
                  sigma Sigs.sequence ->
                  Ctypes.c_object -> loc Sigs.sloc -> Sigs.equation list
                val is_null : loc -> Lang.F.pred
                val loc_eq : loc -> loc -> Lang.F.pred
                val loc_lt : loc -> loc -> Lang.F.pred
                val loc_neq : loc -> loc -> Lang.F.pred
                val loc_leq : loc -> loc -> Lang.F.pred
                val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
                val valid : sigma -> Sigs.acs -> segment -> Lang.F.pred
                val frame : sigma -> Lang.F.pred list
                val alloc : sigma -> Cil_types.varinfo list -> sigma
                val initialized : sigma -> segment -> Lang.F.pred
                val invalid : sigma -> segment -> Lang.F.pred
                val scope :
                  sigma Sigs.sequence ->
                  Sigs.scope -> Cil_types.varinfo list -> Lang.F.pred list
                val global : sigma -> Lang.F.term -> Lang.F.pred
                val included : segment -> segment -> Lang.F.pred
                val separated : segment -> segment -> Lang.F.pred
              end
            type loc = M.loc
            type nonrec value = M.loc Sigs.value
            type nonrec logic = M.loc Sigs.logic
            type nonrec region = M.loc Sigs.region
            type nonrec result = M.loc Sigs.result
            type sigma = M.Sigma.t
            type frame
            val pp_frame : Format.formatter -> frame -> unit
            val get_frame : unit -> frame
            val in_frame : frame -> ('-> 'b) -> '-> 'b
            val mem_at_frame : frame -> Clabels.c_label -> sigma
            val set_at_frame : frame -> Clabels.c_label -> sigma -> unit
            val has_at_frame : frame -> Clabels.c_label -> bool
            val mem_frame : Clabels.c_label -> sigma
            val mk_frame :
              ?kf:Cil_types.kernel_function ->
              ?result:result ->
              ?status:Lang.F.var ->
              ?formals:value Cil_datatype.Varinfo.Map.t ->
              ?labels:sigma Clabels.LabelMap.t ->
              ?descr:string -> unit -> frame
            val local : descr:string -> frame
            val frame : Cil_types.kernel_function -> frame
            type call
            val call :
              ?result:M.loc ->
              Cil_types.kernel_function -> value list -> call
            val call_pre : sigma -> call -> sigma -> frame
            val call_post : sigma -> call -> sigma Sigs.sequence -> frame
            val return : unit -> Cil_types.typ
            val result : unit -> result
            val status : unit -> Lang.F.var
            val guards : frame -> Lang.F.pred list
            type env
            val mk_env :
              ?here:sigma -> ?lvars:Cil_types.logic_var list -> unit -> env
            val current : env -> sigma
            val move_at : env -> sigma -> env
            val mem_at : env -> Clabels.c_label -> sigma
            val env_at : env -> Clabels.c_label -> env
            val lval : env -> Cil_types.term_lval -> Cil_types.typ * M.loc
            val term : env -> Cil_types.term -> Lang.F.term
            val pred :
              Sigs.polarity -> env -> Cil_types.predicate -> Lang.F.pred
            val call_pred :
              env ->
              Cil_types.logic_info ->
              Cil_types.logic_label list -> Lang.F.term list -> Lang.F.pred
            val region : env -> Cil_types.term -> region
            val assigned_of_lval : env -> Cil_types.lval -> region
            val assigned_of_froms : env -> Cil_types.from list -> region
            val assigned_of_assigns :
              env -> Cil_types.assigns -> region option
            val val_of_term : env -> Cil_types.term -> Lang.F.term
            val loc_of_term : env -> Cil_types.term -> loc
            val lemma : LogicUsage.logic_lemma -> Definitions.dlemma
            val vars : region -> Lang.F.Vars.t
            val occurs : Lang.F.var -> region -> bool
            val check_assigns :
              unfold:int ->
              sigma -> written:region -> assignable:region -> Lang.F.pred
          end
    end
  module Sigma :
    sig
      module Make :
        functor (C : Sigs.Chunk)
          (H : sig
                 type t = C.t
                 type set
                 type 'a map
                 val hash : t -> int
                 val equal : t -> t -> bool
                 val compare : t -> t -> int
                 module Map :
                   sig
                     type key = t
                     type 'a t = 'a map
                     val empty : 'a t
                     val add : key -> '-> 'a t -> 'a t
                     val mem : key -> 'a t -> bool
                     val find : key -> 'a t -> 'a
                     val findk : key -> 'a t -> key * 'a
                     val size : 'a t -> int
                     val is_empty : 'a t -> bool
                     val insert :
                       (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                     val change :
                       (key -> '-> 'a option -> 'a option) ->
                       key -> '-> 'a t -> 'a t
                     val map : ('-> 'b) -> 'a t -> 'b t
                     val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                     val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                     val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                     val filter : (key -> '-> bool) -> 'a t -> 'a t
                     val partition :
                       (key -> '-> bool) -> 'a t -> 'a t * 'a t
                     val iter : (key -> '-> unit) -> 'a t -> unit
                     val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                     val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                     val fold_sorted :
                       (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                     val union :
                       (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                     val inter :
                       (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                     val interf :
                       (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                     val interq :
                       (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                     val diffq :
                       (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                     val subset :
                       (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                     val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                     val iterk :
                       (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                     val iter2 :
                       (key -> 'a option -> 'b option -> unit) ->
                       'a t -> 'b t -> unit
                     val merge :
                       (key -> 'a option -> 'b option -> 'c option) ->
                       'a t -> 'b t -> 'c t
                     type domain = set
                     val domain : 'a t -> domain
                   end
                 module Set :
                   sig
                     type elt = t
                     type t = set
                     val empty : t
                     val add : elt -> t -> t
                     val singleton : elt -> t
                     val elements : t -> elt list
                     val is_empty : t -> bool
                     val mem : elt -> t -> bool
                     val iter : (elt -> unit) -> t -> unit
                     val fold : (elt -> '-> 'a) -> t -> '-> 'a
                     val filter : (elt -> bool) -> t -> t
                     val partition : (elt -> bool) -> t -> t * t
                     val for_all : (elt -> bool) -> t -> bool
                     val exists : (elt -> bool) -> t -> bool
                     val iter_sorted : (elt -> unit) -> t -> unit
                     val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                     val union : t -> t -> t
                     val inter : t -> t -> t
                     val diff : t -> t -> t
                     val subset : t -> t -> bool
                     val intersect : t -> t -> bool
                     val of_list : elt list -> t
                     type 'a mapping = 'a map
                     val mapping : (elt -> 'a) -> t -> 'a mapping
                   end
               end)
          ->
          sig
            type chunk = C.t
            module Chunk :
              sig
                type t = C.t
                type set = H.set
                type 'a map = 'H.map
                val hash : t -> int
                val equal : t -> t -> bool
                val compare : t -> t -> int
                module Map :
                  sig
                    type key = t
                    type 'a t = 'a map
                    val empty : 'a t
                    val add : key -> '-> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val find : key -> 'a t -> 'a
                    val findk : key -> 'a t -> key * 'a
                    val size : 'a t -> int
                    val is_empty : 'a t -> bool
                    val insert :
                      (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                    val change :
                      (key -> '-> 'a option -> 'a option) ->
                      key -> '-> 'a t -> 'a t
                    val map : ('-> 'b) -> 'a t -> 'b t
                    val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                    val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                    val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                    val filter : (key -> '-> bool) -> 'a t -> 'a t
                    val partition :
                      (key -> '-> bool) -> 'a t -> 'a t * 'a t
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                    val fold_sorted :
                      (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val union :
                      (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val inter :
                      (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val interf :
                      (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                    val interq :
                      (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                    val diffq :
                      (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                    val subset :
                      (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val iterk :
                      (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                    val iter2 :
                      (key -> 'a option -> 'b option -> unit) ->
                      'a t -> 'b t -> unit
                    val merge :
                      (key -> 'a option -> 'b option -> 'c option) ->
                      'a t -> 'b t -> 'c t
                    type domain = set
                    val domain : 'a t -> domain
                  end
                module Set :
                  sig
                    type elt = t
                    type t = set
                    val empty : t
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val elements : t -> elt list
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val iter_sorted : (elt -> unit) -> t -> unit
                    val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val subset : t -> t -> bool
                    val intersect : t -> t -> bool
                    val of_list : elt list -> t
                    type 'a mapping = 'a map
                    val mapping : (elt -> 'a) -> t -> 'a mapping
                  end
              end
            type domain = Chunk.Set.t
            type t
            val pretty : Format.formatter -> t -> unit
            val create : unit -> t
            val mem : t -> chunk -> bool
            val get : t -> chunk -> Lang.F.var
            val value : t -> chunk -> Lang.F.term
            val copy : t -> t
            val join : t -> t -> Passive.t
            val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
            val choose : t -> t -> t
            val merge : t -> t -> t * Passive.t * Passive.t
            val merge_list : t list -> t * Passive.t list
            val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
            val iter2 :
              (chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
              t -> t -> unit
            val havoc_chunk : t -> chunk -> t
            val havoc : t -> domain -> t
            val havoc_any : call:bool -> t -> t
            val remove_chunks : t -> domain -> t
            val domain : t -> domain
            val union : domain -> domain -> domain
            val empty : domain
            val writes : t Sigs.sequence -> domain
          end
    end
  module MemVar :
    sig
      module type VarUsage =
        sig
          val datatype : string
          val param : Cil_types.varinfo -> Wp.MemoryContext.param
          val iter :
            ?kf:Cil_types.kernel_function ->
            init:bool -> (Cil_types.varinfo -> unit) -> unit
        end
      module Make : functor (V : VarUsage) (M : Sigs.Model-> Sigs.Model
    end
  module MemTyped :
    sig
      val configure : unit -> WpContext.rollback
      val configure_ia :
        Interpreted_automata.automaton ->
        Interpreted_automata.vertex Sigs.binder
      val datatype : string
      val hypotheses : MemoryContext.partition -> MemoryContext.partition
      module Chunk : Sigs.Chunk
      module Heap :
        sig
          type t = Chunk.t
          type set
          type 'a map
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          module Map :
            sig
              type key = t
              type 'a t = 'a map
              val empty : 'a t
              val add : key -> '-> 'a t -> 'a t
              val mem : key -> 'a t -> bool
              val find : key -> 'a t -> 'a
              val findk : key -> 'a t -> key * 'a
              val size : 'a t -> int
              val is_empty : 'a t -> bool
              val insert :
                (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
              val change :
                (key -> '-> 'a option -> 'a option) ->
                key -> '-> 'a t -> 'a t
              val map : ('-> 'b) -> 'a t -> 'b t
              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
              val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
              val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
              val filter : (key -> '-> bool) -> 'a t -> 'a t
              val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
              val iter : (key -> '-> unit) -> 'a t -> unit
              val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val iter_sorted : (key -> '-> unit) -> 'a t -> unit
              val fold_sorted : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
              val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val interf :
                (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
              val interq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val diffq :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val subset : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val iterk : (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
              val iter2 :
                (key -> 'a option -> 'b option -> unit) ->
                'a t -> 'b t -> unit
              val merge :
                (key -> 'a option -> 'b option -> 'c option) ->
                'a t -> 'b t -> 'c t
              type domain = set
              val domain : 'a t -> domain
            end
          module Set :
            sig
              type elt = t
              type t = set
              val empty : t
              val add : elt -> t -> t
              val singleton : elt -> t
              val elements : t -> elt list
              val is_empty : t -> bool
              val mem : elt -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val filter : (elt -> bool) -> t -> t
              val partition : (elt -> bool) -> t -> t * t
              val for_all : (elt -> bool) -> t -> bool
              val exists : (elt -> bool) -> t -> bool
              val iter_sorted : (elt -> unit) -> t -> unit
              val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val subset : t -> t -> bool
              val intersect : t -> t -> bool
              val of_list : elt list -> t
              type 'a mapping = 'a map
              val mapping : (elt -> 'a) -> t -> 'a mapping
            end
        end
      module Sigma :
        sig
          type chunk = Chunk.t
          module Chunk :
            sig
              type t = Chunk.t
              type set = Heap.set
              type 'a map = 'Heap.map
              val hash : t -> int
              val equal : t -> t -> bool
              val compare : t -> t -> int
              module Map :
                sig
                  type key = t
                  type 'a t = 'a map
                  val empty : 'a t
                  val add : key -> '-> 'a t -> 'a t
                  val mem : key -> 'a t -> bool
                  val find : key -> 'a t -> 'a
                  val findk : key -> 'a t -> key * 'a
                  val size : 'a t -> int
                  val is_empty : 'a t -> bool
                  val insert :
                    (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                  val change :
                    (key -> '-> 'a option -> 'a option) ->
                    key -> '-> 'a t -> 'a t
                  val map : ('-> 'b) -> 'a t -> 'b t
                  val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                  val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                  val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                  val fold_sorted :
                    (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                  val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val interf :
                    (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                  val interq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val diffq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val subset :
                    (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iterk :
                    (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                  val iter2 :
                    (key -> 'a option -> 'b option -> unit) ->
                    'a t -> 'b t -> unit
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  type domain = set
                  val domain : 'a t -> domain
                end
              module Set :
                sig
                  type elt = t
                  type t = set
                  val empty : t
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val elements : t -> elt list
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val filter : (elt -> bool) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val iter_sorted : (elt -> unit) -> t -> unit
                  val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val subset : t -> t -> bool
                  val intersect : t -> t -> bool
                  val of_list : elt list -> t
                  type 'a mapping = 'a map
                  val mapping : (elt -> 'a) -> t -> 'a mapping
                end
            end
          type domain = Chunk.Set.t
          type t
          val pretty : Format.formatter -> t -> unit
          val create : unit -> t
          val mem : t -> chunk -> bool
          val get : t -> chunk -> Lang.F.var
          val value : t -> chunk -> Lang.F.term
          val copy : t -> t
          val join : t -> t -> Passive.t
          val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
          val choose : t -> t -> t
          val merge : t -> t -> t * Passive.t * Passive.t
          val merge_list : t list -> t * Passive.t list
          val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
          val iter2 :
            (chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
            t -> t -> unit
          val havoc_chunk : t -> chunk -> t
          val havoc : t -> domain -> t
          val havoc_any : call:bool -> t -> t
          val remove_chunks : t -> domain -> t
          val domain : t -> domain
          val union : domain -> domain -> domain
          val empty : domain
          val writes : t Sigs.sequence -> domain
        end
      type loc
      type chunk = Chunk.t
      type sigma = Sigma.t
      type domain = Sigma.domain
      type segment = loc Sigs.rloc
      type state
      val state : sigma -> state
      val lookup : state -> Lang.F.term -> Sigs.mval
      val updates : state Sigs.sequence -> Lang.F.Vars.t -> Sigs.update Bag.t
      val apply : (Lang.F.term -> Lang.F.term) -> state -> state
      val iter : (Sigs.mval -> Lang.F.term -> unit) -> state -> unit
      val pretty : Format.formatter -> loc -> unit
      val vars : loc -> Lang.F.Vars.t
      val occurs : Lang.F.var -> loc -> bool
      val null : loc
      val literal : eid:int -> Cstring.cst -> loc
      val cvar : Cil_types.varinfo -> loc
      val pointer_loc : Lang.F.term -> loc
      val pointer_val : loc -> Lang.F.term
      val field : loc -> Cil_types.fieldinfo -> loc
      val shift : loc -> Ctypes.c_object -> Lang.F.term -> loc
      val base_addr : loc -> loc
      val base_offset : loc -> Lang.F.term
      val block_length : sigma -> Ctypes.c_object -> loc -> Lang.F.term
      val cast : Ctypes.c_object Sigs.sequence -> loc -> loc
      val loc_of_int : Ctypes.c_object -> Lang.F.term -> loc
      val int_of_loc : Ctypes.c_int -> loc -> Lang.F.term
      val domain : Ctypes.c_object -> loc -> domain
      val is_well_formed : sigma -> Lang.F.pred
      val load : sigma -> Ctypes.c_object -> loc -> loc Sigs.value
      val load_init : sigma -> Ctypes.c_object -> loc -> Lang.F.term
      val copied :
        sigma Sigs.sequence ->
        Ctypes.c_object -> loc -> loc -> Sigs.equation list
      val copied_init :
        sigma Sigs.sequence ->
        Ctypes.c_object -> loc -> loc -> Sigs.equation list
      val stored :
        sigma Sigs.sequence ->
        Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
      val stored_init :
        sigma Sigs.sequence ->
        Ctypes.c_object -> loc -> Lang.F.term -> Sigs.equation list
      val assigned :
        sigma Sigs.sequence ->
        Ctypes.c_object -> loc Sigs.sloc -> Sigs.equation list
      val is_null : loc -> Lang.F.pred
      val loc_eq : loc -> loc -> Lang.F.pred
      val loc_lt : loc -> loc -> Lang.F.pred
      val loc_neq : loc -> loc -> Lang.F.pred
      val loc_leq : loc -> loc -> Lang.F.pred
      val loc_diff : Ctypes.c_object -> loc -> loc -> Lang.F.term
      val valid : sigma -> Sigs.acs -> segment -> Lang.F.pred
      val frame : sigma -> Lang.F.pred list
      val alloc : sigma -> Cil_types.varinfo list -> sigma
      val initialized : sigma -> segment -> Lang.F.pred
      val invalid : sigma -> segment -> Lang.F.pred
      val scope :
        sigma Sigs.sequence ->
        Sigs.scope -> Cil_types.varinfo list -> Lang.F.pred list
      val global : sigma -> Lang.F.term -> Lang.F.pred
      val included : segment -> segment -> Lang.F.pred
      val separated : segment -> segment -> Lang.F.pred
      type pointer = NoCast | Fits | Unsafe
      val pointer : Wp.MemTyped.pointer Wp.Context.value
    end
  module MemVal :
    sig
      module type State =
        sig
          type t
          val bottom : Wp.MemVal.State.t
          val join :
            Wp.MemVal.State.t -> Wp.MemVal.State.t -> Wp.MemVal.State.t
          val of_kinstr : Cil_types.kinstr -> Wp.MemVal.State.t
          val of_stmt : Cil_types.stmt -> Wp.MemVal.State.t
          val of_kf : Cil_types.kernel_function -> Wp.MemVal.State.t
          val pretty : Stdlib.Format.formatter -> Wp.MemVal.State.t -> unit
        end
      module type Value =
        sig
          val configure : unit -> Wp.WpContext.rollback
          val datatype : string
          module State : State
          type t
          type state = Wp.MemVal.State.t
          val null : Wp.MemVal.Value.t
          val literal : eid:int -> Wp.Cstring.cst -> int * Wp.MemVal.Value.t
          val cvar : Cil_types.varinfo -> Wp.MemVal.Value.t
          val field :
            Wp.MemVal.Value.t -> Cil_types.fieldinfo -> Wp.MemVal.Value.t
          val shift :
            Wp.MemVal.Value.t ->
            Wp.Ctypes.c_object -> Wp.Lang.F.term -> Wp.MemVal.Value.t
          val base_addr : Wp.MemVal.Value.t -> Wp.MemVal.Value.t
          val load :
            Wp.MemVal.Value.state ->
            Wp.MemVal.Value.t -> Wp.Ctypes.c_object -> Wp.MemVal.Value.t
          val domain : Wp.MemVal.Value.t -> Base.t list
          val offset : Wp.MemVal.Value.t -> Wp.Lang.F.term -> Wp.Lang.F.pred
          val pretty : Stdlib.Format.formatter -> Wp.MemVal.Value.t -> unit
        end
      module Make : functor (V : Value-> Sigs.Model
      module Eva : Value
    end
  module CfgCompiler :
    sig
      type mode = [ `Bool_Backward | `Bool_Forward | `Tree ]
      module type Cfg =
        sig
          module S : Sigs.Sigma
          module Node :
            sig
              type t
              module Map :
                sig
                  type key = t
                  type 'a t
                  val is_empty : 'a t -> bool
                  val empty : 'a t
                  val add : key -> '-> 'a t -> 'a t
                  val mem : key -> 'a t -> bool
                  val find : key -> 'a t -> 'a
                  val remove : key -> 'a t -> 'a t
                  val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val iter : (key -> '-> unit) -> 'a t -> unit
                  val map : (key -> '-> 'b) -> 'a t -> 'b t
                  val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                  val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                  val filter : (key -> '-> bool) -> 'a t -> 'a t
                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                  val inter : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val interf :
                    (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                  val interq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val diffq :
                    (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                  val merge :
                    (key -> 'a option -> 'b option -> 'c option) ->
                    'a t -> 'b t -> 'c t
                  val iter2 :
                    (key -> 'a option -> 'b option -> unit) ->
                    'a t -> 'b t -> unit
                  val subset :
                    (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                  val insert :
                    (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                  val change :
                    (key -> '-> 'a option -> 'a option) ->
                    key -> '-> 'a t -> 'a t
                end
              module Set :
                sig
                  type elt = t
                  type t
                  val empty : t
                  val is_empty : t -> bool
                  val mem : elt -> t -> bool
                  val find : elt -> t -> elt
                  val add : elt -> t -> t
                  val singleton : elt -> t
                  val remove : elt -> t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val compare : t -> t -> int
                  val equal : t -> t -> bool
                  val subset : t -> t -> bool
                  val iter : (elt -> unit) -> t -> unit
                  val fold : (elt -> '-> 'a) -> t -> '-> 'a
                  val for_all : (elt -> bool) -> t -> bool
                  val exists : (elt -> bool) -> t -> bool
                  val filter : (elt -> bool) -> t -> t
                  val partition : (elt -> bool) -> t -> t * t
                  val cardinal : t -> int
                  val elements : t -> elt list
                  val map : (elt -> elt) -> t -> t
                  val mapf : (elt -> elt option) -> t -> t
                  val intersect : t -> t -> bool
                end
              module Hashtbl :
                sig
                  type key = t
                  type !'a t
                  val create : int -> 'a t
                  val clear : 'a t -> unit
                  val reset : '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_opt : 'a t -> key -> 'a option
                  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 filter_map_inplace :
                    (key -> '-> 'a option) -> 'a t -> unit
                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                  val length : 'a t -> int
                  val stats : 'a t -> Hashtbl.statistics
                  val to_seq : 'a t -> (key * 'a) Seq.t
                  val to_seq_keys : 'a t -> key Seq.t
                  val to_seq_values : 'a t -> 'Seq.t
                  val add_seq : 'a t -> (key * 'a) Seq.t -> unit
                  val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
                  val of_seq : (key * 'a) Seq.t -> 'a t
                end
              val pp :
                Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.Node.t -> unit
              val create : unit -> Wp.CfgCompiler.Cfg.Node.t
              val equal :
                Wp.CfgCompiler.Cfg.Node.t ->
                Wp.CfgCompiler.Cfg.Node.t -> bool
            end
          type node = Wp.CfgCompiler.Cfg.Node.t
          val node : unit -> Wp.CfgCompiler.Cfg.node
          module C :
            sig
              type t
              val equal :
                Wp.CfgCompiler.Cfg.C.t -> Wp.CfgCompiler.Cfg.C.t -> bool
              val create : S.t -> Wp.Lang.F.pred -> Wp.CfgCompiler.Cfg.C.t
              val get : Wp.CfgCompiler.Cfg.C.t -> Wp.Lang.F.pred
              val reads : Wp.CfgCompiler.Cfg.C.t -> S.domain
              val relocate :
                S.t -> Wp.CfgCompiler.Cfg.C.t -> Wp.CfgCompiler.Cfg.C.t
            end
          module P :
            sig
              type t
              val pretty :
                Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.P.t -> unit
              val create :
                S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
                Wp.Lang.F.pred -> Wp.CfgCompiler.Cfg.P.t
              val get : Wp.CfgCompiler.Cfg.P.t -> Wp.Lang.F.pred
              val reads :
                Wp.CfgCompiler.Cfg.P.t ->
                S.domain Wp.CfgCompiler.Cfg.Node.Map.t
              val nodes :
                Wp.CfgCompiler.Cfg.P.t -> Wp.CfgCompiler.Cfg.Node.Set.t
              val relocate :
                S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
                Wp.CfgCompiler.Cfg.P.t -> Wp.CfgCompiler.Cfg.P.t
              val to_condition :
                Wp.CfgCompiler.Cfg.P.t ->
                (Wp.CfgCompiler.Cfg.C.t * Wp.CfgCompiler.Cfg.Node.t option)
                option
            end
          module T :
            sig
              type t
              val pretty :
                Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.T.t -> unit
              val create :
                S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
                Wp.Lang.F.term -> Wp.CfgCompiler.Cfg.T.t
              val get : Wp.CfgCompiler.Cfg.T.t -> Wp.Lang.F.term
              val reads :
                Wp.CfgCompiler.Cfg.T.t ->
                S.domain Wp.CfgCompiler.Cfg.Node.Map.t
              val relocate :
                S.t Wp.CfgCompiler.Cfg.Node.Map.t ->
                Wp.CfgCompiler.Cfg.T.t -> Wp.CfgCompiler.Cfg.T.t
              val init :
                Wp.CfgCompiler.Cfg.Node.Set.t ->
                (S.t Wp.CfgCompiler.Cfg.Node.Map.t -> Wp.Lang.F.term) ->
                Wp.CfgCompiler.Cfg.T.t
              val init' :
                Wp.CfgCompiler.Cfg.Node.t ->
                (S.t -> Wp.Lang.F.term) -> Wp.CfgCompiler.Cfg.T.t
            end
          module E :
            sig
              type t
              val pretty :
                Stdlib.Format.formatter -> Wp.CfgCompiler.Cfg.E.t -> unit
              val create :
                S.t Wp.Sigs.sequence ->
                Wp.Lang.F.pred -> Wp.CfgCompiler.Cfg.E.t
              val get : Wp.CfgCompiler.Cfg.E.t -> Wp.Lang.F.pred
              val reads : Wp.CfgCompiler.Cfg.E.t -> S.domain
              val writes : Wp.CfgCompiler.Cfg.E.t -> S.domain
              val relocate :
                S.t Wp.Sigs.sequence ->
                Wp.CfgCompiler.Cfg.E.t -> Wp.CfgCompiler.Cfg.E.t
            end
          type cfg
          val dump_env : name:string -> Wp.CfgCompiler.Cfg.cfg -> unit
          val output_dot :
            Stdlib.out_channel ->
            ?checks:Wp.CfgCompiler.Cfg.P.t Bag.t ->
            Wp.CfgCompiler.Cfg.cfg -> unit
          val nop : Wp.CfgCompiler.Cfg.cfg
          val add_tmpnode : Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val concat :
            Wp.CfgCompiler.Cfg.cfg ->
            Wp.CfgCompiler.Cfg.cfg -> Wp.CfgCompiler.Cfg.cfg
          val meta :
            ?stmt:Cil_types.stmt ->
            ?descr:string ->
            Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val goto :
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val branch :
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.C.t ->
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val guard :
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.C.t ->
            Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val guard' :
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.C.t ->
            Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val either :
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.node list -> Wp.CfgCompiler.Cfg.cfg
          val implies :
            Wp.CfgCompiler.Cfg.node ->
            (Wp.CfgCompiler.Cfg.C.t * Wp.CfgCompiler.Cfg.node) list ->
            Wp.CfgCompiler.Cfg.cfg
          val effect :
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.E.t ->
            Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val assume : Wp.CfgCompiler.Cfg.P.t -> Wp.CfgCompiler.Cfg.cfg
          val havoc :
            Wp.CfgCompiler.Cfg.node ->
            effects:Wp.CfgCompiler.Cfg.node Wp.Sigs.sequence ->
            Wp.CfgCompiler.Cfg.node -> Wp.CfgCompiler.Cfg.cfg
          val compile :
            ?name:string ->
            ?mode:Wp.CfgCompiler.mode ->
            Wp.CfgCompiler.Cfg.node ->
            Wp.CfgCompiler.Cfg.Node.Set.t ->
            S.domain Wp.CfgCompiler.Cfg.Node.Map.t ->
            Wp.CfgCompiler.Cfg.cfg ->
            Wp.Lang.F.pred Wp.CfgCompiler.Cfg.Node.Map.t *
            S.t Wp.CfgCompiler.Cfg.Node.Map.t * Wp.Conditions.sequence
        end
      module Cfg :
        functor (S : Sigs.Sigma->
          sig
            module S :
              sig
                type chunk = S.chunk
                module Chunk :
                  sig
                    type t = chunk
                    type set = S.Chunk.set
                    type 'a map = 'S.Chunk.map
                    val hash : t -> int
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    module Map :
                      sig
                        type key = t
                        type 'a t = 'a map
                        val empty : 'a t
                        val add : key -> '-> 'a t -> 'a t
                        val mem : key -> 'a t -> bool
                        val find : key -> 'a t -> 'a
                        val findk : key -> 'a t -> key * 'a
                        val size : 'a t -> int
                        val is_empty : 'a t -> bool
                        val insert :
                          (key -> '-> '-> 'a) ->
                          key -> '-> 'a t -> 'a t
                        val change :
                          (key -> '-> 'a option -> 'a option) ->
                          key -> '-> 'a t -> 'a t
                        val map : ('-> 'b) -> 'a t -> 'b t
                        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                        val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                        val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                        val filter : (key -> '-> bool) -> 'a t -> 'a t
                        val partition :
                          (key -> '-> bool) -> 'a t -> 'a t * 'a t
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val iter_sorted : (key -> '-> unit) -> 'a t -> unit
                        val fold_sorted :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val union :
                          (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                        val inter :
                          (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                        val interf :
                          (key -> '-> '-> 'c option) ->
                          'a t -> 'b t -> 'c t
                        val interq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val diffq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val subset :
                          (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val iterk :
                          (key -> '-> '-> unit) -> 'a t -> 'b t -> unit
                        val iter2 :
                          (key -> 'a option -> 'b option -> unit) ->
                          'a t -> 'b t -> unit
                        val merge :
                          (key -> 'a option -> 'b option -> 'c option) ->
                          'a t -> 'b t -> 'c t
                        type domain = set
                        val domain : 'a t -> domain
                      end
                    module Set :
                      sig
                        type elt = t
                        type t = set
                        val empty : t
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val elements : t -> elt list
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val iter_sorted : (elt -> unit) -> t -> unit
                        val fold_sorted : (elt -> '-> 'a) -> t -> '-> 'a
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val subset : t -> t -> bool
                        val intersect : t -> t -> bool
                        val of_list : elt list -> t
                        type 'a mapping = 'a map
                        val mapping : (elt -> 'a) -> t -> 'a mapping
                      end
                  end
                type domain = Chunk.Set.t
                type t = S.t
                val pretty : Format.formatter -> t -> unit
                val create : unit -> t
                val mem : t -> chunk -> bool
                val get : t -> chunk -> Lang.F.var
                val value : t -> chunk -> Lang.F.term
                val copy : t -> t
                val join : t -> t -> Passive.t
                val assigned : pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                val choose : t -> t -> t
                val merge : t -> t -> t * Passive.t * Passive.t
                val merge_list : t list -> t * Passive.t list
                val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                val iter2 :
                  (chunk -> Lang.F.var option -> Lang.F.var option -> unit) ->
                  t -> t -> unit
                val havoc_chunk : t -> chunk -> t
                val havoc : t -> domain -> t
                val havoc_any : call:bool -> t -> t
                val remove_chunks : t -> domain -> t
                val domain : t -> domain
                val union : domain -> domain -> domain
                val empty : domain
                val writes : t Sigs.sequence -> domain
              end
            module Node :
              sig
                type t
                module Map :
                  sig
                    type key = t
                    type 'a t
                    val is_empty : 'a t -> bool
                    val empty : 'a t
                    val add : key -> '-> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val find : key -> 'a t -> 'a
                    val remove : key -> 'a t -> 'a t
                    val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val map : (key -> '-> 'b) -> 'a t -> 'b t
                    val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                    val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                    val filter : (key -> '-> bool) -> 'a t -> 'a t
                    val partition :
                      (key -> '-> bool) -> 'a t -> 'a t * 'a t
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val union :
                      (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val inter :
                      (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val interf :
                      (key -> '-> '-> 'c option) -> 'a t -> 'b t -> 'c t
                    val interq :
                      (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                    val diffq :
                      (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                    val merge :
                      (key -> 'a option -> 'b option -> 'c option) ->
                      'a t -> 'b t -> 'c t
                    val iter2 :
                      (key -> 'a option -> 'b option -> unit) ->
                      'a t -> 'b t -> unit
                    val subset :
                      (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                    val insert :
                      (key -> '-> '-> 'a) -> key -> '-> 'a t -> 'a t
                    val change :
                      (key -> '-> 'a option -> 'a option) ->
                      key -> '-> 'a t -> 'a t
                  end
                module Set :
                  sig
                    type elt = t
                    type t
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val find : elt -> t -> elt
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val map : (elt -> elt) -> t -> t
                    val mapf : (elt -> elt option) -> t -> t
                    val intersect : t -> t -> bool
                  end
                module Hashtbl :
                  sig
                    type key = t
                    type !'a t
                    val create : int -> 'a t
                    val clear : 'a t -> unit
                    val reset : '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_opt : 'a t -> key -> 'a option
                    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 filter_map_inplace :
                      (key -> '-> 'a option) -> 'a t -> unit
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val length : 'a t -> int
                    val stats : 'a t -> Hashtbl.statistics
                    val to_seq : 'a t -> (key * 'a) Seq.t
                    val to_seq_keys : 'a t -> key Seq.t
                    val to_seq_values : 'a t -> 'Seq.t
                    val add_seq : 'a t -> (key * 'a) Seq.t -> unit
                    val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
                    val of_seq : (key * 'a) Seq.t -> 'a t
                  end
                val pp : Format.formatter -> t -> unit
                val create : unit -> t
                val equal : t -> t -> bool
              end
            type node = Node.t
            val node : unit -> node
            module C :
              sig
                type t
                val equal : t -> t -> bool
                val create : S.t -> Lang.F.pred -> t
                val get : t -> Lang.F.pred
                val reads : t -> S.domain
                val relocate : S.t -> t -> t
              end
            module P :
              sig
                type t
                val pretty : Format.formatter -> t -> unit
                val create : S.t Node.Map.t -> Lang.F.pred -> t
                val get : t -> Lang.F.pred
                val reads : t -> S.domain Node.Map.t
                val nodes : t -> Node.Set.t
                val relocate : S.t Node.Map.t -> t -> t
                val to_condition : t -> (C.t * Node.t option) option
              end
            module T :
              sig
                type t
                val pretty : Format.formatter -> t -> unit
                val create : S.t Node.Map.t -> Lang.F.term -> t
                val get : t -> Lang.F.term
                val reads : t -> S.domain Node.Map.t
                val relocate : S.t Node.Map.t -> t -> t
                val init : Node.Set.t -> (S.t Node.Map.t -> Lang.F.term) -> t
                val init' : Node.t -> (S.t -> Lang.F.term) -> t
              end
            module E :
              sig
                type t
                val pretty : Format.formatter -> t -> unit
                val create : S.t Sigs.sequence -> Lang.F.pred -> t
                val get : t -> Lang.F.pred
                val reads : t -> S.domain
                val writes : t -> S.domain
                val relocate : S.t Sigs.sequence -> t -> t
              end
            type cfg
            val dump_env : name:string -> cfg -> unit
            val output_dot : out_channel -> ?checks:P.t Bag.t -> cfg -> unit
            val nop : cfg
            val add_tmpnode : node -> cfg
            val concat : cfg -> cfg -> cfg
            val meta : ?stmt:Cil_types.stmt -> ?descr:string -> node -> cfg
            val goto : node -> node -> cfg
            val branch : node -> C.t -> node -> node -> cfg
            val guard : node -> C.t -> node -> cfg
            val guard' : node -> C.t -> node -> cfg
            val either : node -> node list -> cfg
            val implies : node -> (C.t * node) list -> cfg
            val effect : node -> E.t -> node -> cfg
            val assume : P.t -> cfg
            val havoc : node -> effects:node Sigs.sequence -> node -> cfg
            val compile :
              ?name:string ->
              ?mode:mode ->
              node ->
              Node.Set.t ->
              S.domain Node.Map.t ->
              cfg ->
              Lang.F.pred Node.Map.t * S.t Node.Map.t * Conditions.sequence
          end
    end
  module StmtSemantics :
    sig
      module Make :
        functor (Compiler : Sigs.Compiler->
          sig
            module Cfg :
              sig
                module S :
                  sig
                    type chunk = Compiler.M.Chunk.t
                    module Chunk :
                      sig
                        type t = Compiler.M.Chunk.t
                        type set = Compiler.M.Heap.set
                        type 'a map = 'Compiler.M.Heap.map
                        val hash : t -> int
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        module Map :
                          sig
                            type key = t
                            type 'a t = 'a map
                            val empty : 'a t
                            val add : key -> '-> 'a t -> 'a t
                            val mem : key -> 'a t -> bool
                            val find : key -> 'a t -> 'a
                            val findk : key -> 'a t -> key * 'a
                            val size : 'a t -> int
                            val is_empty : 'a t -> bool
                            val insert :
                              (key -> '-> '-> 'a) ->
                              key -> '-> 'a t -> 'a t
                            val change :
                              (key -> '-> 'a option -> 'a option) ->
                              key -> '-> 'a t -> 'a t
                            val map : ('-> 'b) -> 'a t -> 'b t
                            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                            val mapf :
                              (key -> '-> 'b option) -> 'a t -> 'b t
                            val mapq :
                              (key -> '-> 'a option) -> 'a t -> 'a t
                            val filter : (key -> '-> bool) -> 'a t -> 'a t
                            val partition :
                              (key -> '-> bool) -> 'a t -> 'a t * 'a t
                            val iter : (key -> '-> unit) -> 'a t -> unit
                            val fold :
                              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                            val iter_sorted :
                              (key -> '-> unit) -> 'a t -> unit
                            val fold_sorted :
                              (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                            val union :
                              (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                            val inter :
                              (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                            val interf :
                              (key -> '-> '-> 'c option) ->
                              'a t -> 'b t -> 'c t
                            val interq :
                              (key -> '-> '-> 'a option) ->
                              'a t -> 'a t -> 'a t
                            val diffq :
                              (key -> '-> '-> 'a option) ->
                              'a t -> 'a t -> 'a t
                            val subset :
                              (key -> '-> '-> bool) ->
                              'a t -> 'b t -> bool
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val iterk :
                              (key -> '-> '-> unit) ->
                              'a t -> 'b t -> unit
                            val iter2 :
                              (key -> 'a option -> 'b option -> unit) ->
                              'a t -> 'b t -> unit
                            val merge :
                              (key -> 'a option -> 'b option -> 'c option) ->
                              'a t -> 'b t -> 'c t
                            type domain = set
                            val domain : 'a t -> domain
                          end
                        module Set :
                          sig
                            type elt = t
                            type t = set
                            val empty : t
                            val add : elt -> t -> t
                            val singleton : elt -> t
                            val elements : t -> elt list
                            val is_empty : t -> bool
                            val mem : elt -> t -> bool
                            val iter : (elt -> unit) -> t -> unit
                            val fold : (elt -> '-> 'a) -> t -> '-> 'a
                            val filter : (elt -> bool) -> t -> t
                            val partition : (elt -> bool) -> t -> t * t
                            val for_all : (elt -> bool) -> t -> bool
                            val exists : (elt -> bool) -> t -> bool
                            val iter_sorted : (elt -> unit) -> t -> unit
                            val fold_sorted :
                              (elt -> '-> 'a) -> t -> '-> 'a
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val subset : t -> t -> bool
                            val intersect : t -> t -> bool
                            val of_list : elt list -> t
                            type 'a mapping = 'a map
                            val mapping : (elt -> 'a) -> t -> 'a mapping
                          end
                      end
                    type domain = Chunk.Set.t
                    type t = Compiler.M.Sigma.t
                    val pretty : Format.formatter -> t -> unit
                    val create : unit -> t
                    val mem : t -> chunk -> bool
                    val get : t -> chunk -> Lang.F.var
                    val value : t -> chunk -> Lang.F.term
                    val copy : t -> t
                    val join : t -> t -> Passive.t
                    val assigned :
                      pre:t -> post:t -> domain -> Lang.F.pred Bag.t
                    val choose : t -> t -> t
                    val merge : t -> t -> t * Passive.t * Passive.t
                    val merge_list : t list -> t * Passive.t list
                    val iter : (chunk -> Lang.F.var -> unit) -> t -> unit
                    val iter2 :
                      (chunk ->
                       Lang.F.var option -> Lang.F.var option -> unit) ->
                      t -> t -> unit
                    val havoc_chunk : t -> chunk -> t
                    val havoc : t -> domain -> t
                    val havoc_any : call:bool -> t -> t
                    val remove_chunks : t -> domain -> t
                    val domain : t -> domain
                    val union : domain -> domain -> domain
                    val empty : domain
                    val writes : t Sigs.sequence -> domain
                  end
                module Node :
                  sig
                    type t
                    module Map :
                      sig
                        type key = t
                        type 'a t
                        val is_empty : 'a t -> bool
                        val empty : 'a t
                        val add : key -> '-> 'a t -> 'a t
                        val mem : key -> 'a t -> bool
                        val find : key -> 'a t -> 'a
                        val remove : key -> 'a t -> 'a t
                        val compare :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val map : (key -> '-> 'b) -> 'a t -> 'b t
                        val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
                        val mapq : (key -> '-> 'a option) -> 'a t -> 'a t
                        val filter : (key -> '-> bool) -> 'a t -> 'a t
                        val partition :
                          (key -> '-> bool) -> 'a t -> 'a t * 'a t
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val union :
                          (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                        val inter :
                          (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                        val interf :
                          (key -> '-> '-> 'c option) ->
                          'a t -> 'b t -> 'c t
                        val interq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val diffq :
                          (key -> '-> '-> 'a option) ->
                          'a t -> 'a t -> 'a t
                        val merge :
                          (key -> 'a option -> 'b option -> 'c option) ->
                          'a t -> 'b t -> 'c t
                        val iter2 :
                          (key -> 'a option -> 'b option -> unit) ->
                          'a t -> 'b t -> unit
                        val subset :
                          (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                        val insert :
                          (key -> '-> '-> 'a) ->
                          key -> '-> 'a t -> 'a t
                        val change :
                          (key -> '-> 'a option -> 'a option) ->
                          key -> '-> 'a t -> 'a t
                      end
                    module Set :
                      sig
                        type elt = t
                        type t
                        val empty : t
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val find : elt -> t -> elt
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val remove : elt -> t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val compare : t -> t -> int
                        val equal : t -> t -> bool
                        val subset : t -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val cardinal : t -> int
                        val elements : t -> elt list
                        val map : (elt -> elt) -> t -> t
                        val mapf : (elt -> elt option) -> t -> t
                        val intersect : t -> t -> bool
                      end
                    module Hashtbl :
                      sig
                        type key = t
                        type !'a t
                        val create : int -> 'a t
                        val clear : 'a t -> unit
                        val reset : '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_opt : 'a t -> key -> 'a option
                        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 filter_map_inplace :
                          (key -> '-> 'a option) -> 'a t -> unit
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val length : 'a t -> int
                        val stats : 'a t -> Hashtbl.statistics
                        val to_seq : 'a t -> (key * 'a) Seq.t
                        val to_seq_keys : 'a t -> key Seq.t
                        val to_seq_values : 'a t -> 'Seq.t
                        val add_seq : 'a t -> (key * 'a) Seq.t -> unit
                        val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
                        val of_seq : (key * 'a) Seq.t -> 'a t
                      end
                    val pp : Format.formatter -> t -> unit
                    val create : unit -> t
                    val equal : t -> t -> bool
                  end
                type node = Node.t
                val node : unit -> node
                module C :
                  sig
                    type t
                    val equal : t -> t -> bool
                    val create : S.t -> Lang.F.pred -> t
                    val get : t -> Lang.F.pred
                    val reads : t -> S.domain
                    val relocate : S.t -> t -> t
                  end
                module P :
                  sig
                    type t
                    val pretty : Format.formatter -> t -> unit
                    val create : S.t Node.Map.t -> Lang.F.pred -> t
                    val get : t -> Lang.F.pred
                    val reads : t -> S.domain Node.Map.t
                    val nodes : t -> Node.Set.t
                    val relocate : S.t Node.Map.t -> t -> t
                    val to_condition : t -> (C.t * Node.t option) option
                  end
                module T :
                  sig
                    type t
                    val pretty : Format.formatter -> t -> unit
                    val create : S.t Node.Map.t -> Lang.F.term -> t
                    val get : t -> Lang.F.term
                    val reads : t -> S.domain Node.Map.t
                    val relocate : S.t Node.Map.t -> t -> t
                    val init :
                      Node.Set.t -> (S.t Node.Map.t -> Lang.F.term) -> t
                    val init' : Node.t -> (S.t -> Lang.F.term) -> t
                  end
                module E :
                  sig
                    type t
                    val pretty : Format.formatter -> t -> unit
                    val create : S.t Sigs.sequence -> Lang.F.pred -> t
                    val get : t -> Lang.F.pred
                    val reads : t -> S.domain
                    val writes : t -> S.domain
                    val relocate : S.t Sigs.sequence -> t -> t
                  end
                type cfg
                val dump_env : name:string -> cfg -> unit
                val output_dot :
                  out_channel -> ?checks:P.t Bag.t -> cfg -> unit
                val nop : cfg
                val add_tmpnode : node -> cfg
                val concat : cfg -> cfg -> cfg
                val meta :
                  ?stmt:Cil_types.stmt -> ?descr:string -> node -> cfg
                val goto : node -> node -> cfg
                val branch : node -> C.t -> node -> node -> cfg
                val guard : node -> C.t -> node -> cfg
                val guard' : node -> C.t -> node -> cfg
                val either : node -> node list -> cfg
                val implies : node -> (C.t * node) list -> cfg
                val effect : node -> E.t -> node -> cfg
                val assume : P.t -> cfg
                val havoc : node -> effects:node Sigs.sequence -> node -> cfg
                val compile :
                  ?name:string ->
                  ?mode:CfgCompiler.mode ->
                  node ->
                  Node.Set.t ->
                  S.domain Node.Map.t ->
                  cfg ->
                  Lang.F.pred Node.Map.t * S.t Node.Map.t *
                  Conditions.sequence
              end
            type node = Wp.StmtSemantics.Make.Cfg.node
            type goal = {
              goal_pred : Wp.StmtSemantics.Make.Cfg.P.t;
              goal_prop : Wp.WpPropId.prop_id;
            }
            type cfg = Wp.StmtSemantics.Make.Cfg.cfg
            type paths = {
              paths_cfg : Wp.StmtSemantics.Make.cfg;
              paths_goals : Wp.StmtSemantics.Make.goal Bag.t;
            }
            val goals_nodes :
              Wp.StmtSemantics.Make.goal Bag.t ->
              Wp.StmtSemantics.Make.Cfg.Node.Set.t
            exception LabelNotFound of Wp.Clabels.c_label
            type env
            val empty_env : Kernel_function.t -> Wp.StmtSemantics.Make.env
            val bind :
              Wp.Clabels.c_label ->
              Wp.StmtSemantics.Make.node ->
              Wp.StmtSemantics.Make.env -> Wp.StmtSemantics.Make.env
            val result : Wp.StmtSemantics.Make.env -> Wp.Lang.F.var
            val ( @^ ) :
              Wp.StmtSemantics.Make.paths ->
              Wp.StmtSemantics.Make.paths -> Wp.StmtSemantics.Make.paths
            val ( @* ) :
              Wp.StmtSemantics.Make.env ->
              (Wp.Clabels.c_label * Wp.StmtSemantics.Make.node) list ->
              Wp.StmtSemantics.Make.env
            val ( @: ) :
              Wp.StmtSemantics.Make.env ->
              Wp.Clabels.c_label -> Wp.StmtSemantics.Make.node
            val ( @- ) :
              Wp.StmtSemantics.Make.env ->
              (Wp.Clabels.c_label -> bool) -> Wp.StmtSemantics.Make.env
            val sequence :
              (Wp.StmtSemantics.Make.env -> '-> Wp.StmtSemantics.Make.paths) ->
              Wp.StmtSemantics.Make.env ->
              'a list -> Wp.StmtSemantics.Make.paths
            val choice :
              ?pre:Wp.Clabels.c_label ->
              ?post:Wp.Clabels.c_label ->
              (Wp.StmtSemantics.Make.env -> '-> Wp.StmtSemantics.Make.paths) ->
              Wp.StmtSemantics.Make.env ->
              'a list -> Wp.StmtSemantics.Make.paths
            val parallel :
              ?pre:Wp.Clabels.c_label ->
              ?post:Wp.Clabels.c_label ->
              (Wp.StmtSemantics.Make.env ->
               '->
               Wp.StmtSemantics.Make.Cfg.C.t * Wp.StmtSemantics.Make.paths) ->
              Wp.StmtSemantics.Make.env ->
              'a list -> Wp.StmtSemantics.Make.paths
            val set :
              Wp.StmtSemantics.Make.env ->
              Cil_types.lval -> Cil_types.exp -> Wp.StmtSemantics.Make.paths
            val scope :
              Wp.StmtSemantics.Make.env ->
              Wp.Sigs.scope ->
              Cil_types.varinfo list -> Wp.StmtSemantics.Make.paths
            val instr :
              Wp.StmtSemantics.Make.env ->
              Cil_types.instr -> Wp.StmtSemantics.Make.paths
            val return :
              Wp.StmtSemantics.Make.env ->
              Cil_types.exp option -> Wp.StmtSemantics.Make.paths
            val assume :
              Wp.StmtSemantics.Make.Cfg.P.t -> Wp.StmtSemantics.Make.paths
            val call_kf :
              Wp.StmtSemantics.Make.env ->
              Cil_types.lval option ->
              Cil_types.kernel_function ->
              Cil_types.exp list -> Wp.StmtSemantics.Make.paths
            val call :
              Wp.StmtSemantics.Make.env ->
              Cil_types.lval option ->
              Cil_types.exp ->
              Cil_types.exp list -> Wp.StmtSemantics.Make.paths
            val spec :
              Wp.StmtSemantics.Make.env ->
              Cil_types.spec -> Wp.StmtSemantics.Make.paths
            val assume_ :
              Wp.StmtSemantics.Make.env ->
              Wp.Sigs.polarity ->
              Cil_types.predicate -> Wp.StmtSemantics.Make.paths
            val assigns :
              Wp.StmtSemantics.Make.env ->
              Cil_types.assigns -> Wp.StmtSemantics.Make.paths
            val froms :
              Wp.StmtSemantics.Make.env ->
              Cil_types.from list -> Wp.StmtSemantics.Make.paths
            val automaton :
              Wp.StmtSemantics.Make.env ->
              Interpreted_automata.automaton -> Wp.StmtSemantics.Make.paths
            val init :
              is_pre_main:bool ->
              Wp.StmtSemantics.Make.env -> Wp.StmtSemantics.Make.paths
            val compute_kf :
              Kernel_function.t ->
              Wp.StmtSemantics.Make.paths * Wp.StmtSemantics.Make.node
          end
    end
  module Factory :
    sig
      type mheap =
          Hoare
        | ZeroAlias
        | Region
        | Typed of Wp.MemTyped.pointer
        | Eva
      type mvar = Raw | Var | Ref | Caveat
      type setup = {
        mvar : Wp.Factory.mvar;
        mheap : Wp.Factory.mheap;
        cint : Wp.Cint.model;
        cfloat : Wp.Cfloat.model;
      }
      type driver = Wp.LogicBuiltins.driver
      val ident : Wp.Factory.setup -> string
      val descr : Wp.Factory.setup -> string
      val compiler :
        Wp.Factory.mheap -> Wp.Factory.mvar -> (module Wp.Sigs.Compiler)
      val configure_driver :
        Wp.Factory.setup ->
        Wp.Factory.driver -> unit -> Wp.WpContext.rollback
      val instance :
        Wp.Factory.setup -> Wp.Factory.driver -> Wp.WpContext.model
      val default : Wp.Factory.setup
      val parse :
        ?default:Wp.Factory.setup ->
        ?warning:(string -> unit) -> string list -> Wp.Factory.setup
    end
  module Driver : sig val load_driver : unit -> Wp.LogicBuiltins.driver end
  module VCS :
    sig
      type prover = Why3 of Why3Provers.t | Qed | Tactical
      type mode = Batch | Update | Edit | Fix | FixUpdate
      module Pset :
        sig
          type elt = prover
          type t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val disjoint : t -> t -> bool
          val diff : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val map : (elt -> elt) -> t -> t
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val filter_map : (elt -> elt option) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val split : elt -> t -> t * bool * t
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val of_list : elt list -> t
          val to_seq_from : elt -> t -> elt Seq.t
          val to_seq : t -> elt Seq.t
          val to_rev_seq : t -> elt Seq.t
          val add_seq : elt Seq.t -> t -> t
          val of_seq : elt Seq.t -> t
        end
      module Pmap :
        sig
          type key = prover
          type +!'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
      val name_of_prover : Wp.VCS.prover -> string
      val title_of_prover : Wp.VCS.prover -> string
      val filename_for_prover : Wp.VCS.prover -> string
      val title_of_mode : Wp.VCS.mode -> string
      val parse_mode : string -> Wp.VCS.mode
      val parse_prover : string -> Wp.VCS.prover option
      val pp_prover : Stdlib.Format.formatter -> Wp.VCS.prover -> unit
      val pp_mode : Stdlib.Format.formatter -> Wp.VCS.mode -> unit
      val cmp_prover : Wp.VCS.prover -> Wp.VCS.prover -> int
      type config = {
        valid : bool;
        timeout : int option;
        stepout : int option;
      }
      val current : unit -> Wp.VCS.config
      val default : Wp.VCS.config
      val get_timeout :
        ?kf:Kernel_function.t -> smoke:bool -> Wp.VCS.config -> int
      val get_stepout : Wp.VCS.config -> int
      type verdict =
          NoResult
        | Invalid
        | Unknown
        | Timeout
        | Stepout
        | Computing of (unit -> unit)
        | Valid
        | Failed
      type result = {
        verdict : Wp.VCS.verdict;
        cached : bool;
        solver_time : float;
        prover_time : float;
        prover_steps : int;
        prover_errpos : Stdlib.Lexing.position option;
        prover_errmsg : string;
      }
      val no_result : Wp.VCS.result
      val valid : Wp.VCS.result
      val invalid : Wp.VCS.result
      val unknown : Wp.VCS.result
      val stepout : int -> Wp.VCS.result
      val timeout : int -> Wp.VCS.result
      val computing : (unit -> unit) -> Wp.VCS.result
      val failed : ?pos:Stdlib.Lexing.position -> string -> Wp.VCS.result
      val kfailed :
        ?pos:Stdlib.Lexing.position ->
        ('a, Stdlib.Format.formatter, unit, Wp.VCS.result) Stdlib.format4 ->
        'a
      val cached : Wp.VCS.result -> Wp.VCS.result
      val result :
        ?cached:bool ->
        ?solver:float ->
        ?time:float -> ?steps:int -> Wp.VCS.verdict -> Wp.VCS.result
      val is_auto : Wp.VCS.prover -> bool
      val is_verdict : Wp.VCS.result -> bool
      val is_valid : Wp.VCS.result -> bool
      val is_computing : Wp.VCS.result -> bool
      val is_proved : smoke:bool -> Wp.VCS.result -> bool
      val smoked : Wp.VCS.verdict -> Wp.VCS.verdict
      val verdict : smoke:bool -> Wp.VCS.result -> Wp.VCS.verdict
      val configure : Wp.VCS.result -> Wp.VCS.config
      val autofit : Wp.VCS.result -> bool
      val pp_result : Stdlib.Format.formatter -> Wp.VCS.result -> unit
      val pp_result_qualif :
        ?updating:bool ->
        Wp.VCS.prover -> Wp.VCS.result -> Stdlib.Format.formatter -> unit
      val compare : Wp.VCS.result -> Wp.VCS.result -> int
      val merge : Wp.VCS.result -> Wp.VCS.result -> Wp.VCS.result
      val choose : Wp.VCS.result -> Wp.VCS.result -> Wp.VCS.result
      val best : Wp.VCS.result list -> Wp.VCS.result
      val dkey_shell : Wp.Wp_parameters.category
    end
  module Tactical :
    sig
      type clause = Goal of Wp.Lang.F.pred | Step of Wp.Conditions.step
      type process =
          Wp.Conditions.sequent -> (string * Wp.Conditions.sequent) list
      type status =
          Not_applicable
        | Not_configured
        | Applicable of Wp.Tactical.process
      type selection =
          Empty
        | Clause of Wp.Tactical.clause
        | Inside of Wp.Tactical.clause * Wp.Lang.F.term
        | Compose of Wp.Tactical.compose
        | Multi of Wp.Tactical.selection list
      and compose = private
          Cint of Integer.t
        | Range of int * int
        | Code of Wp.Lang.F.term * string * Wp.Tactical.selection list
      val int : int -> Wp.Tactical.selection
      val cint : Integer.t -> Wp.Tactical.selection
      val range : int -> int -> Wp.Tactical.selection
      val compose :
        string -> Wp.Tactical.selection list -> Wp.Tactical.selection
      val multi : Wp.Tactical.selection list -> Wp.Tactical.selection
      val get_int : Wp.Tactical.selection -> int option
      val destruct : Wp.Tactical.selection -> Wp.Tactical.selection list
      val head : Wp.Tactical.clause -> Wp.Lang.F.pred
      val is_empty : Wp.Tactical.selection -> bool
      val selected : Wp.Tactical.selection -> Wp.Lang.F.term
      val subclause : Wp.Tactical.clause -> Wp.Lang.F.pred -> bool
      val pp_clause : Stdlib.Format.formatter -> Wp.Tactical.clause -> unit
      val pp_selection :
        Stdlib.Format.formatter -> Wp.Tactical.selection -> unit
      type 'a field
      module Fmap :
        sig
          type t
          val create : unit -> Wp.Tactical.Fmap.t
          val get : Wp.Tactical.Fmap.t -> 'Wp.Tactical.field -> 'a
          val set : Wp.Tactical.Fmap.t -> 'Wp.Tactical.field -> '-> unit
        end
      type 'a named = {
        title : string;
        descr : string;
        vid : string;
        value : 'a;
      }
      type 'a range = { vmin : 'a option; vmax : 'a option; vstep : 'a; }
      type 'a browser =
          ('Wp.Tactical.named -> unit) -> Wp.Tactical.selection -> unit
      type parameter =
          Checkbox of bool Wp.Tactical.field
        | Spinner of int Wp.Tactical.field * int Wp.Tactical.range
        | Composer of Wp.Tactical.selection Wp.Tactical.field *
            (Wp.Lang.F.term -> bool)
        | Selector : 'Wp.Tactical.field * 'Wp.Tactical.named list *
            ('-> '-> bool) -> Wp.Tactical.parameter
        | Search : 'Wp.Tactical.named option Wp.Tactical.field *
            'Wp.Tactical.browser * (string -> 'a) -> Wp.Tactical.parameter
      val ident : 'Wp.Tactical.field -> string
      val default : 'Wp.Tactical.field -> 'a
      val signature : 'Wp.Tactical.field -> 'Wp.Tactical.named
      val checkbox :
        id:string ->
        title:string ->
        descr:string ->
        ?default:bool ->
        unit -> bool Wp.Tactical.field * Wp.Tactical.parameter
      val spinner :
        id:string ->
        title:string ->
        descr:string ->
        ?default:int ->
        ?vmin:int ->
        ?vmax:int ->
        ?vstep:int -> unit -> int Wp.Tactical.field * Wp.Tactical.parameter
      val selector :
        id:string ->
        title:string ->
        descr:string ->
        ?default:'->
        options:'Wp.Tactical.named list ->
        ?equal:('-> '-> bool) ->
        unit -> 'Wp.Tactical.field * Wp.Tactical.parameter
      val composer :
        id:string ->
        title:string ->
        descr:string ->
        ?default:Wp.Tactical.selection ->
        ?filter:(Wp.Lang.F.term -> bool) ->
        unit ->
        Wp.Tactical.selection Wp.Tactical.field * Wp.Tactical.parameter
      val search :
        id:string ->
        title:string ->
        descr:string ->
        browse:'Wp.Tactical.browser ->
        find:(string -> 'a) ->
        unit ->
        'Wp.Tactical.named option Wp.Tactical.field * Wp.Tactical.parameter
      type 'a formatter =
          ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
      class type feedback =
        object
          method get_title : string
          method has_error : bool
          method interactive : bool
          method pool : Wp.Lang.F.pool
          method set_descr : 'Wp.Tactical.formatter
          method set_error : 'Wp.Tactical.formatter
          method set_title : 'Wp.Tactical.formatter
          method update_field :
            ?enabled:bool ->
            ?title:string ->
            ?tooltip:string ->
            ?range:bool ->
            ?vmin:int ->
            ?vmax:int ->
            ?filter:(Wp.Lang.F.term -> bool) -> 'Wp.Tactical.field -> unit
        end
      val at : Wp.Tactical.selection -> int option
      val mapi : (int -> int -> '-> 'b) -> 'a list -> 'b list
      val insert :
        ?at:int -> (string * Wp.Lang.F.pred) list -> Wp.Tactical.process
      val replace :
        at:int ->
        (string * Wp.Conditions.condition) list -> Wp.Tactical.process
      val replace_single :
        at:int ->
        string * Wp.Conditions.condition ->
        Wp.Conditions.sequent -> string * Wp.Conditions.sequent
      val replace_step :
        at:int -> Wp.Conditions.condition list -> Wp.Tactical.process
      val split : (string * Wp.Lang.F.pred) list -> Wp.Tactical.process
      val rewrite :
        ?at:int ->
        (string * Wp.Lang.F.pred * Wp.Lang.F.term * Wp.Lang.F.term) list ->
        Wp.Tactical.process
      val condition :
        string ->
        Wp.Lang.F.pred -> Wp.Tactical.process -> Wp.Tactical.process
      class type tactical =
        object
          method descr : string
          method get_field : 'Wp.Tactical.field -> 'a
          method id : string
          method params : Wp.Tactical.parameter list
          method reset : unit
          method select :
            Wp.Tactical.feedback ->
            Wp.Tactical.selection -> Wp.Tactical.status
          method set_field : 'Wp.Tactical.field -> '-> unit
          method title : string
        end
      class virtual make :
        id:string ->
        title:string ->
        descr:string ->
        params:Wp.Tactical.parameter list ->
        object
          method descr : string
          method get_field : 'Wp.Tactical.field -> 'a
          method id : string
          method params : Wp.Tactical.parameter list
          method reset : unit
          method virtual select :
            Wp.Tactical.feedback ->
            Wp.Tactical.selection -> Wp.Tactical.status
          method set_field : 'Wp.Tactical.field -> '-> unit
          method title : string
        end
      class type composer =
        object
          method arity : int
          method compute : Wp.Lang.F.term list -> Wp.Lang.F.term
          method descr : string
          method filter : Wp.Lang.F.term list -> bool
          method group : string
          method id : string
          method title : string
        end
      type t = Wp.Tactical.tactical
      val register : #Wp.Tactical.tactical -> unit
      val export : #Wp.Tactical.tactical -> Wp.Tactical.tactical
      val lookup : id:string -> Wp.Tactical.tactical
      val iter : (Wp.Tactical.tactical -> unit) -> unit
      val add_composer : #Wp.Tactical.composer -> unit
      val iter_composer : (Wp.Tactical.composer -> unit) -> unit
    end
  module Strategy :
    sig
      val occurs_x : Wp.Lang.F.var -> Wp.Lang.F.term -> bool
      val occurs_y : Wp.Lang.F.var -> Wp.Lang.F.pred -> bool
      val occurs_e : Wp.Lang.F.term -> Wp.Lang.F.term -> bool
      val occurs_p : Wp.Lang.F.term -> Wp.Lang.F.pred -> bool
      val occurs_q : Wp.Lang.F.pred -> Wp.Lang.F.pred -> bool
      val select_e :
        Wp.Conditions.sequent -> Wp.Lang.F.term -> Wp.Tactical.selection
      val select_p :
        Wp.Conditions.sequent -> Wp.Lang.F.pred -> Wp.Tactical.selection
      type argument = ARG : 'Wp.Tactical.field * '-> Wp.Strategy.argument
      type strategy = {
        priority : float;
        tactical : Wp.Tactical.tactical;
        selection : Wp.Tactical.selection;
        arguments : Wp.Strategy.argument list;
      }
      class pool :
        object
          method add : Wp.Strategy.strategy -> unit
          method sort : Wp.Strategy.strategy array
        end
      class type heuristic =
        object
          method descr : string
          method id : string
          method search :
            (Wp.Strategy.strategy -> unit) -> Wp.Conditions.sequent -> unit
          method title : string
        end
      val register : #Wp.Strategy.heuristic -> unit
      val export : #Wp.Strategy.heuristic -> Wp.Strategy.heuristic
      val lookup : id:string -> Wp.Strategy.heuristic
      val iter : (Wp.Strategy.heuristic -> unit) -> unit
      type t = Wp.Strategy.strategy
      val arg : 'Wp.Tactical.field -> '-> Wp.Strategy.argument
      val make :
        Wp.Tactical.tactical ->
        ?priority:float ->
        ?arguments:Wp.Strategy.argument list ->
        Wp.Tactical.selection -> Wp.Strategy.strategy
      val set_arg : Wp.Tactical.tactical -> Wp.Strategy.argument -> unit
      val set_args :
        Wp.Tactical.tactical -> Wp.Strategy.argument list -> unit
    end
  module Auto :
    sig
      val array :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val choice :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val absurd :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val contrapose :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val compound :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val cut :
        ?priority:float ->
        ?modus:bool -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val filter :
        ?priority:float -> ?anti:bool -> unit -> Wp.Strategy.strategy
      val havoc :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val separated :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val instance :
        ?priority:float ->
        Wp.Tactical.selection ->
        Wp.Tactical.selection list -> Wp.Strategy.strategy
      val lemma :
        ?priority:float ->
        ?at:Wp.Tactical.selection ->
        string -> Wp.Tactical.selection list -> Wp.Strategy.strategy
      val intuition :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val range :
        ?priority:float ->
        Wp.Tactical.selection -> vmin:int -> vmax:int -> Wp.Strategy.strategy
      val split :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val definition :
        ?priority:float -> Wp.Tactical.selection -> Wp.Strategy.strategy
      val auto_split : Wp.Strategy.heuristic
      val auto_range : Wp.Strategy.heuristic
      module Range :
        sig
          type rg
          val compute : Wp.Conditions.sequence -> Wp.Auto.Range.rg
          val ranges : Wp.Auto.Range.rg -> (int * int) Wp.Lang.F.Tmap.t
          val bounds :
            Wp.Auto.Range.rg -> (int option * int option) Wp.Lang.F.Tmap.t
        end
      val t_absurd : Wp.Tactical.process
      val t_id : Wp.Tactical.process
      val t_finally : string -> Wp.Tactical.process
      val t_descr : string -> Wp.Tactical.process -> Wp.Tactical.process
      val t_split :
        ?pos:string -> ?neg:string -> Wp.Lang.F.pred -> Wp.Tactical.process
      val t_cut :
        ?by:string ->
        Wp.Lang.F.pred -> Wp.Tactical.process -> Wp.Tactical.process
      val t_case :
        Wp.Lang.F.pred ->
        Wp.Tactical.process -> Wp.Tactical.process -> Wp.Tactical.process
      val t_cases :
        ?complete:string ->
        (Wp.Lang.F.pred * Wp.Tactical.process) list -> Wp.Tactical.process
      val t_chain :
        Wp.Tactical.process -> Wp.Tactical.process -> Wp.Tactical.process
      val t_range :
        Wp.Lang.F.term ->
        int ->
        int ->
        upper:Wp.Tactical.process ->
        lower:Wp.Tactical.process ->
        range:Wp.Tactical.process -> Wp.Tactical.process
      val t_replace :
        ?equal:string ->
        src:Wp.Lang.F.term ->
        tgt:Wp.Lang.F.term -> Wp.Tactical.process -> Wp.Tactical.process
    end
  module VC :
    sig
      type t
      val get_id : Wp.VC.t -> string
      val get_model : Wp.VC.t -> Wp.WpContext.model
      val get_scope : Wp.VC.t -> Wp.WpContext.scope
      val get_context : Wp.VC.t -> Wp.WpContext.context
      val get_description : Wp.VC.t -> string
      val get_property : Wp.VC.t -> Property.t
      val get_result : Wp.VC.t -> Wp.VCS.prover -> Wp.VCS.result
      val get_results : Wp.VC.t -> (Wp.VCS.prover * Wp.VCS.result) list
      val get_logout : Wp.VC.t -> Wp.VCS.prover -> string
      val get_logerr : Wp.VC.t -> Wp.VCS.prover -> string
      val get_sequent : Wp.VC.t -> Wp.Conditions.sequent
      val get_formula : Wp.VC.t -> Wp.Lang.F.pred
      val is_trivial : Wp.VC.t -> bool
      val is_proved : Wp.VC.t -> bool
      val clear : unit -> unit
      val proof : Property.t -> Wp.VC.t list
      val remove : Property.t -> unit
      val iter_ip : (Wp.VC.t -> unit) -> Property.t -> unit
      val iter_kf :
        (Wp.VC.t -> unit) -> ?bhv:string list -> Kernel_function.t -> unit
      val generate_ip : ?model:string -> Property.t -> Wp.VC.t Bag.t
      val generate_kf :
        ?model:string ->
        ?bhv:string list ->
        ?prop:string list -> Kernel_function.t -> Wp.VC.t Bag.t
      val generate_call : ?model:string -> Cil_types.stmt -> Wp.VC.t Bag.t
      val prove :
        Wp.VC.t ->
        ?config:Wp.VCS.config ->
        ?mode:Wp.VCS.mode ->
        ?start:(Wp.VC.t -> unit) ->
        ?progress:(Wp.VC.t -> string -> unit) ->
        ?result:(Wp.VC.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
        Wp.VCS.prover -> bool Task.task
      val spawn :
        Wp.VC.t ->
        ?config:Wp.VCS.config ->
        ?start:(Wp.VC.t -> unit) ->
        ?progress:(Wp.VC.t -> string -> unit) ->
        ?result:(Wp.VC.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
        ?success:(Wp.VC.t -> Wp.VCS.prover option -> unit) ->
        ?pool:Task.pool -> (Wp.VCS.mode * Wp.VCS.prover) list -> unit
      val server : ?procs:int -> unit -> Task.server
      val command :
        ?provers:Why3.Whyconf.prover list ->
        ?tip:bool -> Wp.VC.t Bag.t -> unit
    end
  module Wpo :
    sig
      type index =
          Axiomatic of string option
        | Function of Cil_types.kernel_function * string option
      module DISK :
        sig
          val cache_log :
            pid:Wp.WpPropId.prop_id ->
            model:Wp.WpContext.model ->
            prover:Wp.VCS.prover -> result:Wp.VCS.result -> string
          val pretty :
            pid:Wp.WpPropId.prop_id ->
            model:Wp.WpContext.model ->
            prover:Wp.VCS.prover ->
            result:Wp.VCS.result -> Stdlib.Format.formatter -> unit
          val file_kf :
            kf:Cil_types.kernel_function ->
            model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
          val file_goal :
            pid:Wp.WpPropId.prop_id ->
            model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
          val file_logout :
            pid:Wp.WpPropId.prop_id ->
            model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
          val file_logerr :
            pid:Wp.WpPropId.prop_id ->
            model:Wp.WpContext.model -> prover:Wp.VCS.prover -> string
        end
      module GOAL :
        sig
          type t
          val dummy : Wp.Wpo.GOAL.t
          val trivial : Wp.Wpo.GOAL.t
          val is_trivial : Wp.Wpo.GOAL.t -> bool
          val make : Wp.Conditions.sequent -> Wp.Wpo.GOAL.t
          val compute : pid:Wp.WpPropId.prop_id -> Wp.Wpo.GOAL.t -> unit
          val compute_proof :
            pid:Wp.WpPropId.prop_id -> Wp.Wpo.GOAL.t -> Wp.Lang.F.pred
          val compute_descr :
            pid:Wp.WpPropId.prop_id -> Wp.Wpo.GOAL.t -> Wp.Conditions.sequent
          val get_descr : Wp.Wpo.GOAL.t -> Wp.Conditions.sequent
          val qed_time : Wp.Wpo.GOAL.t -> float
        end
      module VC_Lemma :
        sig
          type t = {
            lemma : Wp.Definitions.dlemma;
            depends : Wp.LogicUsage.logic_lemma list;
            mutable sequent : Wp.Conditions.sequent option;
          }
          val is_trivial : Wp.Wpo.VC_Lemma.t -> bool
          val cache_descr :
            Wp.Wpo.VC_Lemma.t ->
            (Wp.VCS.prover * Wp.VCS.result) list -> string
        end
      module VC_Annot :
        sig
          type t = {
            axioms : Wp.Definitions.axioms option;
            goal : Wp.Wpo.GOAL.t;
            tags : Wp.Splitter.tag list;
            warn : Wp.Warning.t list;
            deps : Property.Set.t;
            path : Cil_datatype.Stmt.Set.t;
            effect : (Cil_types.stmt * Wp.WpPropId.effect_source) option;
          }
          val is_trivial : Wp.Wpo.VC_Annot.t -> bool
          val resolve : pid:Wp.WpPropId.prop_id -> Wp.Wpo.VC_Annot.t -> bool
          val cache_descr :
            pid:Wp.WpPropId.prop_id ->
            Wp.Wpo.VC_Annot.t ->
            (Wp.VCS.prover * Wp.VCS.result) list -> string
        end
      type formula =
          GoalLemma of Wp.Wpo.VC_Lemma.t
        | GoalAnnot of Wp.Wpo.VC_Annot.t
      type po = Wp.Wpo.t
      and t = {
        po_gid : string;
        po_sid : string;
        po_name : string;
        po_idx : Wp.Wpo.index;
        po_model : Wp.WpContext.model;
        po_pid : Wp.WpPropId.prop_id;
        po_formula : Wp.Wpo.formula;
      }
      module S :
        sig
          type t = po
          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
          module Set :
            sig
              type elt = t
              type t
              val empty : t
              val is_empty : t -> bool
              val mem : elt -> t -> bool
              val add : elt -> t -> t
              val singleton : elt -> t
              val remove : elt -> t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val disjoint : t -> t -> bool
              val diff : t -> t -> t
              val subset : t -> t -> bool
              val iter : (elt -> unit) -> t -> unit
              val map : (elt -> elt) -> t -> t
              val fold : (elt -> '-> 'a) -> t -> '-> 'a
              val for_all : (elt -> bool) -> t -> bool
              val exists : (elt -> bool) -> t -> bool
              val filter : (elt -> bool) -> t -> t
              val filter_map : (elt -> elt option) -> t -> t
              val partition : (elt -> bool) -> t -> t * t
              val cardinal : t -> int
              val elements : t -> elt list
              val min_elt : t -> elt
              val min_elt_opt : t -> elt option
              val max_elt : t -> elt
              val max_elt_opt : t -> elt option
              val choose : t -> elt
              val choose_opt : t -> elt option
              val split : elt -> t -> t * bool * t
              val find : elt -> t -> elt
              val find_opt : elt -> t -> elt option
              val find_first : (elt -> bool) -> t -> elt
              val find_first_opt : (elt -> bool) -> t -> elt option
              val find_last : (elt -> bool) -> t -> elt
              val find_last_opt : (elt -> bool) -> t -> elt option
              val of_list : elt list -> t
              val to_seq_from : elt -> t -> elt Seq.t
              val to_seq : t -> elt Seq.t
              val to_rev_seq : t -> elt Seq.t
              val add_seq : elt Seq.t -> t -> t
              val of_seq : elt Seq.t -> t
              val nearest_elt_le : elt -> t -> elt
              val nearest_elt_ge : elt -> t -> elt
              val ty : t Type.t
              val name : string
              val descr : t Descr.t
              val packed_descr : Structural_descr.pack
              val reprs : t list
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val hash : t -> int
              val pretty_code : Format.formatter -> t -> unit
              val internal_pretty_code :
                Type.precedence -> Format.formatter -> t -> unit
              val pretty : Format.formatter -> t -> unit
              val varname : t -> string
              val mem_project : (Project_skeleton.t -> bool) -> t -> bool
              val copy : t -> t
            end
          module Map :
            sig
              type key = t
              type +!'a t
              val empty : 'a t
              val is_empty : 'a t -> bool
              val mem : key -> 'a t -> bool
              val add : key -> '-> 'a t -> 'a t
              val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
              val singleton : key -> '-> 'a t
              val remove : key -> 'a t -> 'a t
              val merge :
                (key -> 'a option -> 'b option -> 'c option) ->
                'a t -> 'b t -> 'c t
              val union :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val compare : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val iter : (key -> '-> unit) -> 'a t -> unit
              val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val for_all : (key -> '-> bool) -> 'a t -> bool
              val exists : (key -> '-> bool) -> 'a t -> bool
              val filter : (key -> '-> bool) -> 'a t -> 'a t
              val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
              val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
              val cardinal : 'a t -> int
              val bindings : 'a t -> (key * 'a) list
              val min_binding : 'a t -> key * 'a
              val min_binding_opt : 'a t -> (key * 'a) option
              val max_binding : 'a t -> key * 'a
              val max_binding_opt : 'a t -> (key * 'a) option
              val choose : 'a t -> key * 'a
              val choose_opt : 'a t -> (key * 'a) option
              val split : key -> 'a t -> 'a t * 'a option * 'a t
              val find : key -> 'a t -> 'a
              val find_opt : key -> 'a t -> 'a option
              val find_first : (key -> bool) -> 'a t -> key * 'a
              val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
              val find_last : (key -> bool) -> 'a t -> key * 'a
              val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
              val map : ('-> 'b) -> 'a t -> 'b t
              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
              val to_seq : 'a t -> (key * 'a) Seq.t
              val to_rev_seq : 'a t -> (key * 'a) Seq.t
              val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
              val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
              val of_seq : (key * 'a) Seq.t -> 'a t
              module Key :
                sig
                  type t = key
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                end
              module Make :
                functor (Data : Datatype.S->
                  sig
                    type t = Data.t t
                    val ty : t Type.t
                    val name : string
                    val descr : t Descr.t
                    val packed_descr : Structural_descr.pack
                    val reprs : t list
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val hash : t -> int
                    val pretty_code : Format.formatter -> t -> unit
                    val internal_pretty_code :
                      Type.precedence -> Format.formatter -> t -> unit
                    val pretty : Format.formatter -> t -> unit
                    val varname : t -> string
                    val mem_project :
                      (Project_skeleton.t -> bool) -> t -> bool
                    val copy : t -> t
                  end
            end
          module Hashtbl :
            sig
              type key = t
              type !'a t
              val create : int -> 'a t
              val clear : 'a t -> unit
              val reset : '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 filter_map_inplace :
                (key -> '-> 'a option) -> 'a t -> unit
              val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val length : 'a t -> int
              val stats : 'a t -> Hashtbl.statistics
              val to_seq : 'a t -> (key * 'a) Seq.t
              val to_seq_keys : 'a t -> key Seq.t
              val to_seq_values : 'a t -> 'Seq.t
              val add_seq : 'a t -> (key * 'a) Seq.t -> unit
              val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
              val of_seq : (key * 'a) Seq.t -> 'a t
              val iter_sorted :
                ?cmp:(key -> key -> int) ->
                (key -> '-> unit) -> 'a t -> unit
              val fold_sorted :
                ?cmp:(key -> key -> int) ->
                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val iter_sorted_by_entry :
                cmp:(key * '-> key * '-> int) ->
                (key -> '-> unit) -> 'a t -> unit
              val fold_sorted_by_entry :
                cmp:(key * '-> key * '-> int) ->
                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val iter_sorted_by_value :
                cmp:('-> '-> int) -> (key -> '-> unit) -> 'a t -> unit
              val fold_sorted_by_value :
                cmp:('-> '-> int) ->
                (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val find_opt : 'a t -> key -> 'a option
              val find_def : 'a t -> key -> '-> 'a
              val memo : 'a t -> key -> (key -> 'a) -> 'a
              val structural_descr : Structural_descr.t -> Structural_descr.t
              val make_type : 'Type.t -> 'a t Type.t
              module Key :
                sig
                  type t = key
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                end
              module Make :
                functor (Data : Datatype.S->
                  sig
                    type t = Data.t t
                    val ty : t Type.t
                    val name : string
                    val descr : t Descr.t
                    val packed_descr : Structural_descr.pack
                    val reprs : t list
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val hash : t -> int
                    val pretty_code : Format.formatter -> t -> unit
                    val internal_pretty_code :
                      Type.precedence -> Format.formatter -> t -> unit
                    val pretty : Format.formatter -> t -> unit
                    val varname : t -> string
                    val mem_project :
                      (Project_skeleton.t -> bool) -> t -> bool
                    val copy : t -> t
                  end
            end
        end
      module Index : sig type t = index val compare : t -> t -> int end
      module Gmap :
        sig
          type key = index
          type +!'a t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val add : key -> '-> 'a t -> 'a t
          val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
          val singleton : key -> '-> 'a t
          val remove : key -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
          val union : (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val cardinal : 'a t -> int
          val bindings : 'a t -> (key * 'a) list
          val min_binding : 'a t -> key * 'a
          val min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
      val get_gid : Wp.Wpo.t -> string
      val get_property : Wp.Wpo.t -> Property.t
      val get_index : Wp.Wpo.t -> Wp.Wpo.index
      val get_label : Wp.Wpo.t -> string
      val get_model : Wp.Wpo.t -> Wp.WpContext.model
      val get_scope : Wp.Wpo.t -> Wp.WpContext.scope
      val get_context : Wp.Wpo.t -> Wp.WpContext.context
      val get_file_logout : Wp.Wpo.t -> Wp.VCS.prover -> string
      val get_file_logerr : Wp.Wpo.t -> Wp.VCS.prover -> string
      val get_files : Wp.Wpo.t -> (string * string) list
      val qed_time : Wp.Wpo.t -> float
      val clear : unit -> unit
      val remove : Wp.Wpo.t -> unit
      val on_remove : (Wp.Wpo.t -> unit) -> unit
      val add : Wp.Wpo.t -> unit
      val age : Wp.Wpo.t -> int
      val reduce : Wp.Wpo.t -> bool
      val resolve : Wp.Wpo.t -> bool
      val set_result : Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit
      val clear_results : Wp.Wpo.t -> unit
      val compute :
        Wp.Wpo.t -> Wp.Definitions.axioms option * Wp.Conditions.sequent
      val has_verdict : Wp.Wpo.t -> Wp.VCS.prover -> bool
      val get_result : Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result
      val get_results : Wp.Wpo.t -> (Wp.VCS.prover * Wp.VCS.result) list
      val get_proof :
        Wp.Wpo.t -> [ `Failed | `Passed | `Unknown ] * Property.t
      val get_target : Wp.Wpo.t -> Property.t
      val is_trivial : Wp.Wpo.t -> bool
      val is_proved : Wp.Wpo.t -> bool
      val is_unknown : Wp.Wpo.t -> bool
      val is_passed : Wp.Wpo.t -> bool
      val warnings : Wp.Wpo.t -> Wp.Warning.t list
      val is_valid : Wp.VCS.result -> bool
      val get_time : Wp.VCS.result -> float
      val get_steps : Wp.VCS.result -> int
      val is_tactic : Wp.Wpo.t -> bool
      val is_smoke_test : Wp.Wpo.t -> bool
      val iter :
        ?ip:Property.t ->
        ?index:Wp.Wpo.index ->
        ?on_axiomatics:(string option -> unit) ->
        ?on_behavior:(Cil_types.kernel_function -> string option -> unit) ->
        ?on_goal:(Wp.Wpo.t -> unit) -> unit -> unit
      val iter_on_goals : (Wp.Wpo.t -> unit) -> unit
      val goals_of_property : Property.t -> Wp.Wpo.t list
      val bar : string
      val kf_context : Wp.Wpo.index -> Description.kf
      val pp_index : Stdlib.Format.formatter -> Wp.Wpo.index -> unit
      val pp_warnings : Stdlib.Format.formatter -> Wp.Warning.t list -> unit
      val pp_depend : Stdlib.Format.formatter -> Property.t -> unit
      val pp_dependency :
        Description.kf -> Stdlib.Format.formatter -> Property.t -> unit
      val pp_dependencies :
        Description.kf -> Stdlib.Format.formatter -> Property.t list -> unit
      val pp_goal : Stdlib.Format.formatter -> Wp.Wpo.t -> unit
      val pp_title : Stdlib.Format.formatter -> Wp.Wpo.t -> unit
      val pp_logfile :
        Stdlib.Format.formatter -> Wp.Wpo.t -> Wp.VCS.prover -> unit
      val pp_axiomatics : Stdlib.Format.formatter -> string option -> unit
      val pp_function :
        Stdlib.Format.formatter -> Kernel_function.t -> string option -> unit
      val pp_goal_flow : Stdlib.Format.formatter -> Wp.Wpo.t -> unit
      val prover_of_name : string -> Wp.VCS.prover option
      class type generator =
        object
          method compute_call : Cil_types.stmt -> Wp.Wpo.t Bag.t
          method compute_ip : Property.t -> Wp.Wpo.t Bag.t
          method compute_main :
            ?fct:Wp.Wp_parameters.functions ->
            ?bhv:string list -> ?prop:string list -> unit -> Wp.Wpo.t Bag.t
          method model : Wp.WpContext.model
        end
    end
  module ProverTask :
    sig
      class printer :
        Stdlib.Format.formatter ->
        string ->
        object
          method hline : unit
          method lines : unit
          method paragraph : unit
          method printf :
            ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
          method section : string -> unit
        end
      val pp_file : message:string -> file:string -> unit
      class type pattern =
        object
          method get_after : ?offset:int -> int -> string
          method get_float : int -> float
          method get_int : int -> int
          method get_string : int -> string
        end
      val p_group : string -> string
      val p_int : string
      val p_float : string
      val p_string : string
      val p_until_space : string
      val location : string -> int -> Stdlib.Lexing.position
      type logs = [ `BOTH | `ERR | `OUT ]
      class virtual command :
        string ->
        object
          method add : string list -> unit
          method add_float : name:string -> value:float -> unit
          method add_int : name:string -> value:int -> unit
          method add_list : name:string -> string list -> unit
          method add_parameter : name:string -> (unit -> bool) -> unit
          method add_positive : name:string -> value:int -> unit
          method command : string list
          method pretty : Stdlib.Format.formatter -> unit
          method run :
            ?echo:bool ->
            ?logout:string -> ?logerr:string -> unit -> int Task.task
          method set_command : string -> unit
          method timeout : int -> unit
          method validate_pattern :
            ?logs:Wp.ProverTask.logs ->
            ?repeat:bool ->
            Str.regexp -> (Wp.ProverTask.pattern -> unit) -> unit
          method validate_time : (float -> unit) -> unit
        end
      val server : ?procs:int -> unit -> Task.server
      val schedule : 'Task.task -> unit
      val spawn :
        ?monitor:('a option -> unit) ->
        ?pool:Task.pool ->
        all:bool -> smoke:bool -> ('a * bool Task.task) list -> unit
    end
  module Prover :
    sig
      val simplify :
        ?start:(Wp.Wpo.t -> unit) ->
        ?result:(Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
        Wp.Wpo.t -> bool Task.task
      val prove :
        Wp.Wpo.t ->
        ?config:Wp.VCS.config ->
        ?mode:Wp.VCS.mode ->
        ?start:(Wp.Wpo.t -> unit) ->
        ?progress:(Wp.Wpo.t -> string -> unit) ->
        ?result:(Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
        Wp.VCS.prover -> bool Task.task
      val spawn :
        Wp.Wpo.t ->
        delayed:bool ->
        ?config:Wp.VCS.config ->
        ?start:(Wp.Wpo.t -> unit) ->
        ?progress:(Wp.Wpo.t -> string -> unit) ->
        ?result:(Wp.Wpo.t -> Wp.VCS.prover -> Wp.VCS.result -> unit) ->
        ?success:(Wp.Wpo.t -> Wp.VCS.prover option -> unit) ->
        ?pool:Task.pool -> (Wp.VCS.mode * Wp.VCS.prover) list -> unit
    end
end