sig   module type Input = sig val option_name : string val help : string end   module type Input_with_arg =     sig val option_name : string val help : string val arg_name : string end   module type Input_collection =     sig       val option_name : string       val help : string       val arg_name : string       val dependencies : State.t list     end   module type String_datatype =     sig       type t       val ty : t Type.t       val name : string       val descr : t Descr.t       val packed_descr : Structural_descr.pack       val reprs : t list       val equal : t -> t -> bool       val compare : t -> t -> int       val hash : t -> int       val pretty_code : Format.formatter -> t -> unit       val internal_pretty_code :         Type.precedence -> Format.formatter -> t -> unit       val pretty : Format.formatter -> t -> unit       val varname : t -> string       val mem_project : (Project_skeleton.t -> bool) -> t -> bool       val copy : t -> t       val of_string : string -> t       val to_string : t -> string     end   module type String_datatype_with_collections =     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 of_singleton_string : string -> Set.t       val to_string : t -> string     end   module type Value_datatype =     sig       type t       val ty : t Type.t       val name : string       val descr : t Descr.t       val packed_descr : Structural_descr.pack       val reprs : t list       val equal : t -> t -> bool       val compare : t -> t -> int       val hash : t -> int       val pretty_code : Format.formatter -> t -> unit       val internal_pretty_code :         Type.precedence -> Format.formatter -> t -> unit       val pretty : Format.formatter -> t -> unit       val varname : t -> string       val mem_project : (Project_skeleton.t -> bool) -> t -> bool       val copy : t -> t       type key       val of_string :         key:Parameter_sig.Value_datatype.key ->         prev:t option -> string option -> t option       val to_string :         key:Parameter_sig.Value_datatype.key -> t option -> string option     end   module type Multiple_value_datatype =     sig       type t       val ty : t Type.t       val name : string       val descr : t Descr.t       val packed_descr : Structural_descr.pack       val reprs : t list       val equal : t -> t -> bool       val compare : t -> t -> int       val hash : t -> int       val pretty_code : Format.formatter -> t -> unit       val internal_pretty_code :         Type.precedence -> Format.formatter -> t -> unit       val pretty : Format.formatter -> t -> unit       val varname : t -> string       val mem_project : (Project_skeleton.t -> bool) -> t -> bool       val copy : t -> t       type key       val of_string :         key:Parameter_sig.Multiple_value_datatype.key ->         prev:t list option -> string option -> t option       val to_string :         key:Parameter_sig.Multiple_value_datatype.key ->         t option -> string option     end   module type S_no_parameter =     sig       type t       val set : Parameter_sig.S_no_parameter.t -> unit       val add_set_hook :         (Parameter_sig.S_no_parameter.t ->          Parameter_sig.S_no_parameter.t -> unit) ->         unit       val add_update_hook :         (Parameter_sig.S_no_parameter.t ->          Parameter_sig.S_no_parameter.t -> unit) ->         unit       val get : unit -> Parameter_sig.S_no_parameter.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 :         Parameter_sig.S_no_parameter.t ->         Parameter_sig.S_no_parameter.t -> bool       val add_aliases : string list -> unit       val is_set : unit -> bool       val unsafe_set : Parameter_sig.S_no_parameter.t -> unit     end   module type S =     sig       type t       val set : t -> unit       val add_set_hook : (t -> t -> unit) -> unit       val add_update_hook : (t -> t -> unit) -> unit       val get : unit -> t       val clear : unit -> unit       val is_default : unit -> bool       val 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     end   module type Bool =     sig       type t = bool       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       val on : unit -> unit       val off : unit -> unit     end   module type Int =     sig       type t = int       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       val incr : unit -> unit       val set_range : min:int -> max:int -> unit       val get_range : unit -> int * int     end   module type String =     sig       type t = string       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       val set_possible_values : string list -> unit       val get_possible_values : unit -> string list       val get_function_name : unit -> string       val get_plain_string : unit -> string     end   module type With_output =     sig       type t = bool       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       val on : unit -> unit       val off : unit -> unit       val set_output_dependencies : State.t list -> unit       val output : (unit -> unit) -> unit     end   module type Specific_dir =     sig       exception No_dir       val force_dir : bool       val dir : ?error:bool -> unit -> string       val file : ?error:bool -> string -> string       module Dir_name : String     end   module type Collection_category =     sig       type elt       type t = Parameter_sig.Collection_category.elt Parameter_category.t       val none : Parameter_sig.Collection_category.t       val default : unit -> Parameter_sig.Collection_category.t       val all : unit -> Parameter_sig.Collection_category.t       val set_default : Parameter_sig.Collection_category.t -> unit       val add :         string ->         State.t list ->         Parameter_sig.Collection_category.elt Parameter_category.accessor ->         Parameter_sig.Collection_category.t       val enable_all :         State.t list ->         Parameter_sig.Collection_category.elt Parameter_category.accessor ->         Parameter_sig.Collection_category.t       val enable_all_as : Parameter_sig.Collection_category.t -> unit     end   module type Collection =     sig       type t       val set : t -> unit       val add_set_hook : (t -> t -> unit) -> unit       val add_update_hook : (t -> t -> unit) -> unit       val get : unit -> t       val clear : unit -> unit       val is_default : unit -> bool       val 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       val is_empty : unit -> bool       val iter : (Parameter_sig.Collection.elt -> unit) -> unit       val fold : (Parameter_sig.Collection.elt -> '-> 'a) -> '-> 'a       val add : Parameter_sig.Collection.elt -> unit       module As_string : 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     end   module type Set =     sig       type t       val set : t -> unit       val add_set_hook : (t -> t -> unit) -> unit       val add_update_hook : (t -> t -> unit) -> unit       val get : unit -> t       val clear : unit -> unit       val is_default : unit -> bool       val 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       val is_empty : unit -> bool       val iter : (elt -> unit) -> unit       val fold : (elt -> '-> 'a) -> '-> 'a       val add : elt -> unit       module As_string : 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 type String_set =     sig       type t = Datatype.String.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 = string       val is_empty : unit -> bool       val iter : (elt -> unit) -> unit       val fold : (elt -> '-> 'a) -> '-> 'a       val add : elt -> unit       module As_string : 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 type Kernel_function_set =     sig       type t = Cil_datatype.Kf.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 = Cil_types.kernel_function       val is_empty : unit -> bool       val iter : (elt -> unit) -> unit       val fold : (elt -> '-> 'a) -> '-> 'a       val add : elt -> unit       module As_string : 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 type Fundec_set =     sig       type t = Cil_datatype.Fundec.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 = Cil_types.fundec       val is_empty : unit -> bool       val iter : (elt -> unit) -> unit       val fold : (elt -> '-> 'a) -> '-> 'a       val add : elt -> unit       module As_string : 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 type List =     sig       type t       val set : t -> unit       val add_set_hook : (t -> t -> unit) -> unit       val add_update_hook : (t -> t -> unit) -> unit       val get : unit -> t       val clear : unit -> unit       val is_default : unit -> bool       val 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       val is_empty : unit -> bool       val iter : (elt -> unit) -> unit       val fold : (elt -> '-> 'a) -> '-> 'a       val add : elt -> unit       module As_string : 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 type String_list =     sig       type t = string 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 = string       val is_empty : unit -> bool       val iter : (elt -> unit) -> unit       val fold : (elt -> '-> 'a) -> '-> 'a       val add : elt -> unit       module As_string : 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 type Map =     sig       type key       type value       type t       val set : t -> unit       val add_set_hook : (t -> t -> unit) -> unit       val add_update_hook : (t -> t -> unit) -> unit       val get : unit -> t       val clear : unit -> unit       val is_default : unit -> bool       val 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 : 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 : Parameter_sig.Map.key -> Parameter_sig.Map.value       val mem : Parameter_sig.Map.key -> bool     end   module type Multiple_map =     sig       type key       type value       type t       val set : t -> unit       val add_set_hook : (t -> t -> unit) -> unit       val add_update_hook : (t -> t -> unit) -> unit       val get : unit -> t       val clear : unit -> unit       val is_default : unit -> bool       val 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 : 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 :         Parameter_sig.Multiple_map.key ->         Parameter_sig.Multiple_map.value list       val mem : Parameter_sig.Multiple_map.key -> bool     end   module type Builder =     sig       val no_element_of_string : string -> 'a       module Bool :         functor           (X : sig                  val option_name : string                  val help : string                  val default : bool                end->           Bool       module Action : functor (X : Input-> Bool       module False : functor (X : Input-> Bool       module True : functor (X : Input-> Bool       module WithOutput :         functor           (X : sig                  val option_name : string                  val help : string                  val output_by_default : bool                end->           With_output       module Int :         functor           (X : sig                  val option_name : string                  val help : string                  val arg_name : string                  val default : int                end->           Int       module Zero : functor (X : Input_with_arg-> Int       module String :         functor           (X : sig                  val option_name : string                  val help : string                  val arg_name : string                  val default : string                end->           String       module Empty_string : functor (X : Input_with_arg-> 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 -> Parameter_sig.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 : 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 : Input_with_arg-> 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->           String_set       module Kernel_function_set :         functor (X : Input_with_arg-> Kernel_function_set       module Fundec_set : functor (X : Input_with_arg-> 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 : 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 : Input_with_arg-> String_list       module Make_map :         functor           (K : 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 : 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 : 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 : 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 : 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 : 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 : 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 : 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 end