sig   val verbose_atleast : int -> bool   val debug_atleast : int -> bool   val printf :     ?level:int ->     ?dkey:Log.category ->     ?current:bool ->     ?source:Lexing.position ->     ?append:(Format.formatter -> unit) ->     ?header:(Format.formatter -> unit) ->     ?prefix:string ->     ?suffix:string -> ('a, Format.formatter, unit) format -> 'a   val result : ?level:int -> ?dkey:Log.category -> 'Log.pretty_printer   val feedback :     ?ontty:Log.ontty ->     ?level:int -> ?dkey:Log.category -> 'Log.pretty_printer   val debug : ?level:int -> ?dkey:Log.category -> 'Log.pretty_printer   val warning : '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 : ('a, Format.formatter, unit, 'b) format4 -> 'a   val deprecated : string -> now:string -> ('-> 'b) -> '-> 'b   val with_result : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter   val with_warning : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter   val with_error : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter   val with_failure : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter   val log :     ?kind:Log.kind -> ?verbose:int -> ?debug:int -> 'Log.pretty_printer   val with_log :     (Log.event -> 'b) -> ?kind:Log.kind -> ('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 -> Log.category   val get_category : string -> Log.Category_set.t   val get_all_categories : unit -> Log.Category_set.t   val add_debug_keys : Log.Category_set.t -> unit   val del_debug_keys : Log.Category_set.t -> unit   val get_debug_keys : unit -> Log.Category_set.t   val is_debug_key_enabled : Log.category -> bool   val get_debug_keyset : unit -> Log.category list   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 Debug_category : Parameter_sig.String_set   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 no_element_of_string : string -> 'a   module Bool :     functor       (X : sig              val option_name : string              val help : string              val default : bool            end->       Parameter_sig.Bool   module Action : functor (X : Parameter_sig.Input-> Parameter_sig.Bool   module False : functor (X : Parameter_sig.Input-> Parameter_sig.Bool   module True : functor (X : Parameter_sig.Input-> Parameter_sig.Bool   module WithOutput :     functor       (X : sig              val option_name : string              val help : string              val output_by_default : bool            end->       Parameter_sig.With_output   module Int :     functor       (X : sig              val option_name : string              val help : string              val arg_name : string              val default : int            end->       Parameter_sig.Int   module Zero :     functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.Int   module String :     functor       (X : sig              val option_name : string              val help : string              val arg_name : string              val default : string            end->       Parameter_sig.String   module Empty_string :     functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.String   exception Cannot_build of string   module Make_set :     functor       (E : sig              type t              val ty : t Type.t              val name : string              val descr : t Descr.t              val packed_descr : Structural_descr.pack              val reprs : t list              val equal : t -> t -> bool              val compare : t -> t -> int              val hash : t -> int              val pretty_code : Format.formatter -> t -> unit              val internal_pretty_code :                Type.precedence -> Format.formatter -> t -> unit              val pretty : Format.formatter -> t -> unit              val varname : t -> string              val mem_project : (Project_skeleton.t -> bool) -> t -> bool              val copy : t -> t              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 diff : t -> t -> t                  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 choose : t -> elt                  val split : elt -> t -> t * bool * t                  val find : elt -> t -> elt                  val of_list : elt list -> t                  val min_elt : t -> elt                  val max_elt : t -> elt                  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 singleton : key -> '-> 'a t                  val remove : key -> 'a t -> 'a t                  val merge :                    (key -> 'a option -> 'b option -> 'c option) ->                    'a t -> 'b t -> 'c t                  val compare : ('-> '-> int) -> 'a t -> 'a t -> int                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                  val iter : (key -> '-> unit) -> 'a t -> unit                  val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b                  val for_all : (key -> '-> bool) -> 'a t -> bool                  val exists : (key -> '-> bool) -> 'a t -> bool                  val filter : (key -> '-> bool) -> 'a t -> 'a t                  val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t                  val cardinal : 'a t -> int                  val bindings : 'a t -> (key * 'a) list                  val min_binding : 'a t -> key * 'a                  val max_binding : 'a t -> key * 'a                  val choose : 'a t -> key * 'a                  val split : key -> 'a t -> 'a t * 'a option * 'a t                  val find : key -> 'a t -> 'a                  val map : ('-> 'b) -> 'a t -> 'b t                  val mapi : (key -> '-> 'b) -> 'a t -> 'b t                  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 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 structural_descr :                    Structural_descr.t -> Structural_descr.t                  val make_type : 'Type.t -> 'a t Type.t                  val memo : 'a t -> key -> (key -> 'a) -> 'a                  module Key :                    sig                      type t = key                      val ty : t Type.t                      val name : string                      val descr : t Descr.t                      val packed_descr : Structural_descr.pack                      val reprs : t list                      val equal : t -> t -> bool                      val compare : t -> t -> int                      val hash : t -> int                      val pretty_code : Format.formatter -> t -> unit                      val internal_pretty_code :                        Type.precedence -> Format.formatter -> t -> unit                      val pretty : Format.formatter -> t -> unit                      val varname : t -> string                      val mem_project :                        (Project_skeleton.t -> bool) -> t -> bool                      val copy : t -> t                    end                  module Make :                    functor (Data : Datatype.S->                      sig                        type t = Data.t t                        val ty : t Type.t                        val name : string                        val descr : t Descr.t                        val packed_descr : Structural_descr.pack                        val reprs : t list                        val equal : t -> t -> bool                        val compare : t -> t -> int                        val hash : t -> int                        val pretty_code : Format.formatter -> t -> unit                        val internal_pretty_code :                          Type.precedence -> Format.formatter -> t -> unit                        val pretty : Format.formatter -> t -> unit                        val varname : t -> string                        val mem_project :                          (Project_skeleton.t -> bool) -> t -> bool                        val copy : t -> t                      end                end              val of_string : string -> t              val to_string : t -> string              val of_singleton_string : string -> Set.t            end) (X : sig                        val option_name : string                        val help : string                        val arg_name : string                        val dependencies : State.t list                        val default : E.Set.t                      end->       sig         type t = E.Set.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 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 : string list -> unit         val is_set : unit -> bool         val unsafe_set : t -> unit         val parameter : Typed_parameter.t         type elt = E.t         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 mem : elt -> bool         val exists : (elt -> bool) -> bool       end   module String_set :     functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.String_set   module Filled_string_set :     functor       (X : sig              val option_name : string              val help : string              val arg_name : string              val default : Datatype.String.Set.t            end->       Parameter_sig.String_set   module Kernel_function_set :     functor (X : Parameter_sig.Input_with_arg->       Parameter_sig.Kernel_function_set   module Fundec_set :     functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.Fundec_set   module Make_list :     functor       (E : sig              type t              val ty : t Type.t              val name : string              val descr : t Descr.t              val packed_descr : Structural_descr.pack              val reprs : t list              val equal : t -> t -> bool              val compare : t -> t -> int              val hash : t -> int              val pretty_code : Format.formatter -> t -> unit              val internal_pretty_code :                Type.precedence -> Format.formatter -> t -> unit              val pretty : Format.formatter -> t -> unit              val varname : t -> string              val mem_project : (Project_skeleton.t -> bool) -> t -> bool              val copy : t -> t              val of_string : string -> t              val to_string : t -> string              val of_singleton_string : string -> t list            end) (X : sig                        val option_name : string                        val help : string                        val arg_name : string                        val dependencies : State.t list                        val default : E.t list                      end->       sig         type t = E.t list         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 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 : string list -> unit         val is_set : unit -> bool         val unsafe_set : t -> unit         val parameter : Typed_parameter.t         type elt = E.t         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 append_before : t -> unit         val append_after : t -> unit       end   module String_list :     functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.String_list   module Make_map :     functor       (K : Parameter_sig.String_datatype_with_collections) (V : sig                                                                   type t                                                                   val ty :                                                                     t Type.t                                                                   val name :                                                                     string                                                                   val descr :                                                                     t Descr.t                                                                   val packed_descr :                                                                     Structural_descr.pack                                                                   val reprs :                                                                     t list                                                                   val equal :                                                                     t ->                                                                     t -> bool                                                                   val compare :                                                                     t ->                                                                     t -> int                                                                   val hash :                                                                     t -> int                                                                   val pretty_code :                                                                     Format.formatter ->                                                                     t -> unit                                                                   val internal_pretty_code :                                                                     Type.precedence ->                                                                     Format.formatter ->                                                                     t -> unit                                                                   val pretty :                                                                     Format.formatter ->                                                                     t -> unit                                                                   val varname :                                                                     t ->                                                                     string                                                                   val mem_project :                                                                     (Project_skeleton.t ->                                                                     bool) ->                                                                     t -> bool                                                                   val copy :                                                                     t -> t                                                                   type key =                                                                     K.t                                                                   val of_string :                                                                     key:                                                                     key ->                                                                     prev:                                                                     t option ->                                                                     string                                                                     option ->                                                                     t option                                                                   val to_string :                                                                     key:                                                                     key ->                                                                     t option ->                                                                     string                                                                     option                                                                 end) (X :        sig         val option_name : string         val help : string         val arg_name : string         val dependencies : State.t list         val default : V.t K.Map.t       end->       sig         type key = K.t         type value = V.t         type t = V.t K.Map.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 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 : 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 String_map :     functor       (V : sig              type t              val ty : t Type.t              val name : string              val descr : t Descr.t              val packed_descr : Structural_descr.pack              val reprs : t list              val equal : t -> t -> bool              val compare : t -> t -> int              val hash : t -> int              val pretty_code : Format.formatter -> t -> unit              val internal_pretty_code :                Type.precedence -> Format.formatter -> t -> unit              val pretty : Format.formatter -> t -> unit              val varname : t -> string              val mem_project : (Project_skeleton.t -> bool) -> t -> bool              val copy : t -> t              type key = string              val of_string :                key:key -> prev:t option -> string option -> t option              val to_string : key:key -> t option -> string option            end) (X : sig                        val option_name : string                        val help : string                        val arg_name : string                        val default : V.t Datatype.String.Map.t                      end->       sig         type key = string         type value = V.t         type t = V.t Datatype.String.Map.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 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 : 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 Kernel_function_map :     functor       (V : sig              type t              val ty : t Type.t              val name : string              val descr : t Descr.t              val packed_descr : Structural_descr.pack              val reprs : t list              val equal : t -> t -> bool              val compare : t -> t -> int              val hash : t -> int              val pretty_code : Format.formatter -> t -> unit              val internal_pretty_code :                Type.precedence -> Format.formatter -> t -> unit              val pretty : Format.formatter -> t -> unit              val varname : t -> string              val mem_project : (Project_skeleton.t -> bool) -> t -> bool              val copy : t -> t              type key = Cil_types.kernel_function              val of_string :                key:key -> prev:t option -> string option -> t option              val to_string : key:key -> t option -> string option            end) (X : sig                        val option_name : string                        val help : string                        val arg_name : string                        val default : V.t Cil_datatype.Kf.Map.t                      end->       sig         type key = Cil_types.kernel_function         type value = V.t         type t = V.t Cil_datatype.Kf.Map.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 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 : 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 Make_multiple_map :     functor       (K : Parameter_sig.String_datatype_with_collections) (V : sig                                                                   type t                                                                   val ty :                                                                     t Type.t                                                                   val name :                                                                     string                                                                   val descr :                                                                     t Descr.t                                                                   val packed_descr :                                                                     Structural_descr.pack                                                                   val reprs :                                                                     t list                                                                   val equal :                                                                     t ->                                                                     t -> bool                                                                   val compare :                                                                     t ->                                                                     t -> int                                                                   val hash :                                                                     t -> int                                                                   val pretty_code :                                                                     Format.formatter ->                                                                     t -> unit                                                                   val internal_pretty_code :                                                                     Type.precedence ->                                                                     Format.formatter ->                                                                     t -> unit                                                                   val pretty :                                                                     Format.formatter ->                                                                     t -> unit                                                                   val varname :                                                                     t ->                                                                     string                                                                   val mem_project :                                                                     (Project_skeleton.t ->                                                                     bool) ->                                                                     t -> bool                                                                   val copy :                                                                     t -> t                                                                   type key =                                                                     K.t                                                                   val of_string :                                                                     key:                                                                     key ->                                                                     prev:                                                                     t list                                                                     option ->                                                                     string                                                                     option ->                                                                     t option                                                                   val to_string :                                                                     key:                                                                     key ->                                                                     t option ->                                                                     string                                                                     option                                                                 end) (X :        sig         val option_name : string         val help : string         val arg_name : string         val dependencies : State.t list         val default : V.t list K.Map.t       end->       sig         type key = K.t         type value = V.t         type t = V.t list K.Map.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 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 : string list -> unit         val is_set : unit -> bool         val unsafe_set : t -> unit         val parameter : Typed_parameter.t         type elt = key * value list         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 list         val mem : key -> bool       end   module String_multiple_map :     functor       (V : sig              type t              val ty : t Type.t              val name : string              val descr : t Descr.t              val packed_descr : Structural_descr.pack              val reprs : t list              val equal : t -> t -> bool              val compare : t -> t -> int              val hash : t -> int              val pretty_code : Format.formatter -> t -> unit              val internal_pretty_code :                Type.precedence -> Format.formatter -> t -> unit              val pretty : Format.formatter -> t -> unit              val varname : t -> string              val mem_project : (Project_skeleton.t -> bool) -> t -> bool              val copy : t -> t              type key = string              val of_string :                key:key -> prev:t list option -> string option -> t option              val to_string : key:key -> t option -> string option            end) (X : sig                        val option_name : string                        val help : string                        val arg_name : string                        val default : V.t list Datatype.String.Map.t                      end->       sig         type key = string         type value = V.t         type t = V.t list Datatype.String.Map.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 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 : string list -> unit         val is_set : unit -> bool         val unsafe_set : t -> unit         val parameter : Typed_parameter.t         type elt = key * value list         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 list         val mem : key -> bool       end   module Kernel_function_multiple_map :     functor       (V : sig              type t              val ty : t Type.t              val name : string              val descr : t Descr.t              val packed_descr : Structural_descr.pack              val reprs : t list              val equal : t -> t -> bool              val compare : t -> t -> int              val hash : t -> int              val pretty_code : Format.formatter -> t -> unit              val internal_pretty_code :                Type.precedence -> Format.formatter -> t -> unit              val pretty : Format.formatter -> t -> unit              val varname : t -> string              val mem_project : (Project_skeleton.t -> bool) -> t -> bool              val copy : t -> t              type key = Cil_types.kernel_function              val of_string :                key:key -> prev:t list option -> string option -> t option              val to_string : key:key -> t option -> string option            end) (X : sig                        val option_name : string                        val help : string                        val arg_name : string                        val default : V.t list Cil_datatype.Kf.Map.t                      end->       sig         type key = Cil_types.kernel_function         type value = V.t         type t = V.t list Cil_datatype.Kf.Map.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 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 : string list -> unit         val is_set : unit -> bool         val unsafe_set : t -> unit         val parameter : Typed_parameter.t         type elt = key * value list         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 list         val mem : key -> bool       end   val parameters : unit -> Typed_parameter.t list end