sig   module type S =     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     end   type plugin = private {     p_name : string;     p_shortname : string;     p_help : string;     p_parameters : (string, Typed_parameter.t list) Hashtbl.t;   }   module type General_services =     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   val register_kernel : unit -> unit   module Register :     functor       (P : sig val name : string val shortname : string val help : string end->       General_services   val is_share_visible : unit -> unit   val is_session_visible : unit -> unit   val is_config_visible : unit -> unit   val plugin_subpath : string -> unit   val default_msg_keys : string list -> unit   val get_from_shortname : string -> Plugin.plugin   val get_from_name : string -> Plugin.plugin   val is_present : string -> bool   val get : string -> Plugin.plugin   val iter_on_plugins : (Plugin.plugin -> unit) -> unit   val positive_debug_ref : int Pervasives.ref   val session_is_set_ref : (unit -> bool) Pervasives.ref   val session_ref : (unit -> string) Pervasives.ref   val config_is_set_ref : (unit -> bool) Pervasives.ref   val config_ref : (unit -> string) Pervasives.ref end