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 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 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 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 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 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 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 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 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 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 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 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 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 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