sig
  val verbose_atleast : int -> bool
  val debug_atleast : int -> bool
  val printf :
    ?level:int ->
    ?dkey:Log.category ->
    ?current:bool ->
    ?source:Lexing.position ->
    ?append:(Format.formatter -> unit) ->
    ?header:(Format.formatter -> unit) ->
    ?prefix:string ->
    ?suffix:string -> ('a, Format.formatter, unit) format -> 'a
  val result : ?level:int -> ?dkey:Log.category -> 'Log.pretty_printer
  val feedback :
    ?ontty:Log.ontty ->
    ?level:int -> ?dkey:Log.category -> 'Log.pretty_printer
  val debug : ?level:int -> ?dkey:Log.category -> 'Log.pretty_printer
  val debug0 : ?level:int -> ?dkey:Log.category -> unit Log.pretty_printer
  val debug1 :
    ?level:int -> ?dkey:Log.category -> ('-> unit) Log.pretty_printer
  val debug2 :
    ?level:int -> ?dkey:Log.category -> ('-> '-> unit) Log.pretty_printer
  val debug3 :
    ?level:int ->
    ?dkey:Log.category -> ('-> '-> '-> unit) Log.pretty_printer
  val debug4 :
    ?level:int ->
    ?dkey:Log.category -> ('-> '-> '-> '-> unit) Log.pretty_printer
  val debug5 :
    ?level:int ->
    ?dkey:Log.category ->
    ('-> '-> '-> '-> '-> unit) Log.pretty_printer
  val debug6 :
    ?level:int ->
    ?dkey:Log.category ->
    ('-> '-> '-> '-> '-> '-> unit) Log.pretty_printer
  val debug7 :
    ?level:int ->
    ?dkey:Log.category ->
    ('-> '-> '-> '-> '-> '-> '-> unit) Log.pretty_printer
  val debug8 :
    ?level:int ->
    ?dkey:Log.category ->
    ('-> '-> '-> '-> '-> '-> '-> '-> unit) Log.pretty_printer
  val warning : 'Log.pretty_printer
  val error : 'Log.pretty_printer
  val abort : ('a, 'b) Log.pretty_aborter
  val failure : 'Log.pretty_printer
  val fatal : ('a, 'b) Log.pretty_aborter
  val verify : bool -> ('a, bool) Log.pretty_aborter
  val not_yet_implemented : ('a, Format.formatter, unit, 'b) format4 -> 'a
  val deprecated : string -> now:string -> ('-> 'b) -> '-> 'b
  val with_result : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter
  val with_warning : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter
  val with_error : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter
  val with_failure : (Log.event -> 'b) -> ('a, 'b) Log.pretty_aborter
  val log :
    ?kind:Log.kind -> ?verbose:int -> ?debug:int -> 'Log.pretty_printer
  val with_log :
    (Log.event -> 'b) -> ?kind:Log.kind -> ('a, 'b) Log.pretty_aborter
  val register : Log.kind -> (Log.event -> unit) -> unit
  val register_tag_handlers : (string -> string) * (string -> string) -> unit
  val register_category : string -> Log.category
  val get_category : string -> Log.Category_set.t
  val get_all_categories : unit -> Log.Category_set.t
  val add_debug_keys : Log.Category_set.t -> unit
  val del_debug_keys : Log.Category_set.t -> unit
  val get_debug_keys : unit -> Log.Category_set.t
  val is_debug_key_enabled : Log.category -> bool
  val get_debug_keyset : unit -> Log.category list
  val add_group : ?memo:bool -> string -> Cmdline.Group.t
  module Help : Parameter_sig.Bool
  module Verbose : Parameter_sig.Int
  module Debug : Parameter_sig.Int
  module Debug_category : Parameter_sig.String_set
  module Share : Parameter_sig.Specific_dir
  module Session : Parameter_sig.Specific_dir
  module Config : Parameter_sig.Specific_dir
  val help : Cmdline.Group.t
  val messages : Cmdline.Group.t
  val no_element_of_string : string -> 'a
  module Bool :
    functor
      (X : sig
             val option_name : string
             val help : string
             val default : bool
           end->
      Parameter_sig.Bool
  module Action : functor (X : Parameter_sig.Input-> Parameter_sig.Bool
  module False : functor (X : Parameter_sig.Input-> Parameter_sig.Bool
  module True : functor (X : Parameter_sig.Input-> Parameter_sig.Bool
  module WithOutput :
    functor
      (X : sig
             val option_name : string
             val help : string
             val output_by_default : bool
           end->
      Parameter_sig.With_output
  module Int :
    functor
      (X : sig
             val option_name : string
             val help : string
             val arg_name : string
             val default : int
           end->
      Parameter_sig.Int
  module Zero :
    functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.Int
  module String :
    functor
      (X : sig
             val option_name : string
             val help : string
             val arg_name : string
             val default : string
           end->
      Parameter_sig.String
  module Empty_string :
    functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.String
  exception Cannot_build of string
  module Make_set :
    functor
      (E : sig
             type t
             val ty : t Type.t
             val name : string
             val descr : t Descr.t
             val packed_descr : Structural_descr.pack
             val reprs : t list
             val equal : t -> t -> bool
             val compare : t -> t -> int
             val hash : t -> int
             val pretty_code : Format.formatter -> t -> unit
             val internal_pretty_code :
               Type.precedence -> Format.formatter -> t -> unit
             val pretty : Format.formatter -> t -> unit
             val varname : t -> string
             val mem_project : (Project_skeleton.t -> bool) -> t -> bool
             val copy : t -> t
             module Set :
               sig
                 type elt = t
                 type t
                 val empty : t
                 val is_empty : t -> bool
                 val mem : elt -> t -> bool
                 val add : elt -> t -> t
                 val singleton : elt -> t
                 val remove : elt -> t -> t
                 val union : t -> t -> t
                 val inter : t -> t -> t
                 val diff : t -> t -> t
                 val subset : t -> t -> bool
                 val iter : (elt -> unit) -> t -> unit
                 val fold : (elt -> '-> 'a) -> t -> '-> 'a
                 val for_all : (elt -> bool) -> t -> bool
                 val exists : (elt -> bool) -> t -> bool
                 val filter : (elt -> bool) -> t -> t
                 val partition : (elt -> bool) -> t -> t * t
                 val cardinal : t -> int
                 val elements : t -> elt list
                 val choose : t -> elt
                 val split : elt -> t -> t * bool * t
                 val find : elt -> t -> elt
                 val of_list : elt list -> t
                 val min_elt : t -> elt
                 val max_elt : t -> elt
                 val nearest_elt_le : elt -> t -> elt
                 val nearest_elt_ge : elt -> t -> elt
                 val ty : t Type.t
                 val name : string
                 val descr : t Descr.t
                 val packed_descr : Structural_descr.pack
                 val reprs : t list
                 val equal : t -> t -> bool
                 val compare : t -> t -> int
                 val hash : t -> int
                 val pretty_code : Format.formatter -> t -> unit
                 val internal_pretty_code :
                   Type.precedence -> Format.formatter -> t -> unit
                 val pretty : Format.formatter -> t -> unit
                 val varname : t -> string
                 val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                 val copy : t -> t
               end
             module Map :
               sig
                 type key = t
                 type +'a t
                 val empty : 'a t
                 val is_empty : 'a t -> bool
                 val mem : key -> 'a t -> bool
                 val add : key -> '-> 'a t -> 'a t
                 val singleton : key -> '-> 'a t
                 val remove : key -> 'a t -> 'a t
                 val merge :
                   (key -> 'a option -> 'b option -> 'c option) ->
                   'a t -> 'b t -> 'c t
                 val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                 val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                 val iter : (key -> '-> unit) -> 'a t -> unit
                 val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                 val for_all : (key -> '-> bool) -> 'a t -> bool
                 val exists : (key -> '-> bool) -> 'a t -> bool
                 val filter : (key -> '-> bool) -> 'a t -> 'a t
                 val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
                 val cardinal : 'a t -> int
                 val bindings : 'a t -> (key * 'a) list
                 val min_binding : 'a t -> key * 'a
                 val max_binding : 'a t -> key * 'a
                 val choose : 'a t -> key * 'a
                 val split : key -> 'a t -> 'a t * 'a option * 'a t
                 val find : key -> 'a t -> 'a
                 val map : ('-> 'b) -> 'a t -> 'b t
                 val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                 module Key :
                   sig
                     type t = key
                     val ty : t Type.t
                     val name : string
                     val descr : t Descr.t
                     val packed_descr : Structural_descr.pack
                     val reprs : t list
                     val equal : t -> t -> bool
                     val compare : t -> t -> int
                     val hash : t -> int
                     val pretty_code : Format.formatter -> t -> unit
                     val internal_pretty_code :
                       Type.precedence -> Format.formatter -> t -> unit
                     val pretty : Format.formatter -> t -> unit
                     val varname : t -> string
                     val mem_project :
                       (Project_skeleton.t -> bool) -> t -> bool
                     val copy : t -> t
                   end
                 module Make :
                   functor (Data : Datatype.S->
                     sig
                       type t = Data.t t
                       val ty : t Type.t
                       val name : string
                       val descr : t Descr.t
                       val packed_descr : Structural_descr.pack
                       val reprs : t list
                       val equal : t -> t -> bool
                       val compare : t -> t -> int
                       val hash : t -> int
                       val pretty_code : Format.formatter -> t -> unit
                       val internal_pretty_code :
                         Type.precedence -> Format.formatter -> t -> unit
                       val pretty : Format.formatter -> t -> unit
                       val varname : t -> string
                       val mem_project :
                         (Project_skeleton.t -> bool) -> t -> bool
                       val copy : t -> t
                     end
               end
             module Hashtbl :
               sig
                 type key = t
                 type 'a t
                 val create : int -> 'a t
                 val clear : 'a t -> unit
                 val reset : 'a t -> unit
                 val copy : 'a t -> 'a t
                 val add : 'a t -> key -> '-> unit
                 val remove : 'a t -> key -> unit
                 val find : 'a t -> key -> 'a
                 val find_all : 'a t -> key -> 'a list
                 val replace : 'a t -> key -> '-> unit
                 val mem : 'a t -> key -> bool
                 val iter : (key -> '-> unit) -> 'a t -> unit
                 val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                 val length : 'a t -> int
                 val stats : 'a t -> Hashtbl.statistics
                 val iter_sorted :
                   ?cmp:(key -> key -> int) ->
                   (key -> '-> unit) -> 'a t -> unit
                 val fold_sorted :
                   ?cmp:(key -> key -> int) ->
                   (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                 val iter_sorted_by_entry :
                   cmp:(key * '-> key * '-> int) ->
                   (key -> '-> unit) -> 'a t -> unit
                 val fold_sorted_by_entry :
                   cmp:(key * '-> key * '-> int) ->
                   (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                 val iter_sorted_by_value :
                   cmp:('-> '-> int) ->
                   (key -> '-> unit) -> 'a t -> unit
                 val fold_sorted_by_value :
                   cmp:('-> '-> int) ->
                   (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                 val structural_descr :
                   Structural_descr.t -> Structural_descr.t
                 val make_type : 'Type.t -> 'a t Type.t
                 val memo : 'a t -> key -> (key -> 'a) -> 'a
                 module Key :
                   sig
                     type t = key
                     val ty : t Type.t
                     val name : string
                     val descr : t Descr.t
                     val packed_descr : Structural_descr.pack
                     val reprs : t list
                     val equal : t -> t -> bool
                     val compare : t -> t -> int
                     val hash : t -> int
                     val pretty_code : Format.formatter -> t -> unit
                     val internal_pretty_code :
                       Type.precedence -> Format.formatter -> t -> unit
                     val pretty : Format.formatter -> t -> unit
                     val varname : t -> string
                     val mem_project :
                       (Project_skeleton.t -> bool) -> t -> bool
                     val copy : t -> t
                   end
                 module Make :
                   functor (Data : Datatype.S->
                     sig
                       type t = Data.t t
                       val ty : t Type.t
                       val name : string
                       val descr : t Descr.t
                       val packed_descr : Structural_descr.pack
                       val reprs : t list
                       val equal : t -> t -> bool
                       val compare : t -> t -> int
                       val hash : t -> int
                       val pretty_code : Format.formatter -> t -> unit
                       val internal_pretty_code :
                         Type.precedence -> Format.formatter -> t -> unit
                       val pretty : Format.formatter -> t -> unit
                       val varname : t -> string
                       val mem_project :
                         (Project_skeleton.t -> bool) -> t -> bool
                       val copy : t -> t
                     end
               end
             val of_string : string -> t
             val to_string : t -> string
             val of_singleton_string : string -> Set.t
           end) (X : sig
                       val option_name : string
                       val help : string
                       val arg_name : string
                       val default : E.Set.t
                     end->
      sig
        type t = E.Set.t
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = E.t
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val set_default : t -> unit
            val add :
              string -> State.t list -> elt Parameter_category.accessor -> t
            val enable_all :
              State.t list -> elt Parameter_category.accessor -> t
            val enable_all_as : t -> unit
          end
        val mem : elt -> bool
        val exists : (elt -> bool) -> bool
      end
  module String_set :
    functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.String_set
  module Filled_string_set :
    functor
      (X : sig
             val option_name : string
             val help : string
             val arg_name : string
             val default : Datatype.String.Set.t
           end->
      Parameter_sig.String_set
  module Kernel_function_set :
    functor (X : Parameter_sig.Input_with_arg->
      Parameter_sig.Kernel_function_set
  module Fundec_set :
    functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.Fundec_set
  module Make_list :
    functor
      (E : sig
             type t
             val ty : t Type.t
             val name : string
             val descr : t Descr.t
             val packed_descr : Structural_descr.pack
             val reprs : t list
             val equal : t -> t -> bool
             val compare : t -> t -> int
             val hash : t -> int
             val pretty_code : Format.formatter -> t -> unit
             val internal_pretty_code :
               Type.precedence -> Format.formatter -> t -> unit
             val pretty : Format.formatter -> t -> unit
             val varname : t -> string
             val mem_project : (Project_skeleton.t -> bool) -> t -> bool
             val copy : t -> t
             val of_string : string -> t
             val to_string : t -> string
             val of_singleton_string : string -> t list
           end) (X : sig
                       val option_name : string
                       val help : string
                       val arg_name : string
                       val default : E.t list
                     end->
      sig
        type t = E.t list
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = E.t
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val set_default : t -> unit
            val add :
              string -> State.t list -> elt Parameter_category.accessor -> t
            val enable_all :
              State.t list -> elt Parameter_category.accessor -> t
            val enable_all_as : t -> unit
          end
        val append_before : t -> unit
        val append_after : t -> unit
      end
  module String_list :
    functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.String_list
  module Make_map :
    functor
      (K : Parameter_sig.String_datatype_with_collections) (V : sig
                                                                  type t
                                                                  val ty :
                                                                    t Type.t
                                                                  val name :
                                                                    string
                                                                  val descr :
                                                                    t Descr.t
                                                                  val packed_descr :
                                                                    Structural_descr.pack
                                                                  val reprs :
                                                                    t list
                                                                  val equal :
                                                                    t ->
                                                                    t -> bool
                                                                  val compare :
                                                                    t ->
                                                                    t -> int
                                                                  val hash :
                                                                    t -> int
                                                                  val pretty_code :
                                                                    Format.formatter ->
                                                                    t -> unit
                                                                  val internal_pretty_code :
                                                                    Type.precedence ->
                                                                    Format.formatter ->
                                                                    t -> unit
                                                                  val pretty :
                                                                    Format.formatter ->
                                                                    t -> unit
                                                                  val varname :
                                                                    t ->
                                                                    string
                                                                  val mem_project :
                                                                    (Project_skeleton.t ->
                                                                    bool) ->
                                                                    t -> bool
                                                                  val copy :
                                                                    t -> t
                                                                  type key =
                                                                    K.t
                                                                  val of_string :
                                                                    key:
                                                                    key ->
                                                                    prev:
                                                                    t option ->
                                                                    string
                                                                    option ->
                                                                    t option
                                                                  val to_string :
                                                                    key:
                                                                    key ->
                                                                    t option ->
                                                                    string
                                                                    option
                                                                end) (X : 
      sig
        val option_name : string
        val help : string
        val arg_name : string
        val default : V.t K.Map.t
      end->
      sig
        type key = K.t
        type value = V.t
        type t = V.t K.Map.t
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = key * value option
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val set_default : t -> unit
            val add :
              string -> State.t list -> elt Parameter_category.accessor -> t
            val enable_all :
              State.t list -> elt Parameter_category.accessor -> t
            val enable_all_as : t -> unit
          end
        val find : key -> value
        val mem : key -> bool
      end
  module String_map :
    functor
      (V : sig
             type t
             val ty : t Type.t
             val name : string
             val descr : t Descr.t
             val packed_descr : Structural_descr.pack
             val reprs : t list
             val equal : t -> t -> bool
             val compare : t -> t -> int
             val hash : t -> int
             val pretty_code : Format.formatter -> t -> unit
             val internal_pretty_code :
               Type.precedence -> Format.formatter -> t -> unit
             val pretty : Format.formatter -> t -> unit
             val varname : t -> string
             val mem_project : (Project_skeleton.t -> bool) -> t -> bool
             val copy : t -> t
             type key = string
             val of_string :
               key:key -> prev:t option -> string option -> t option
             val to_string : key:key -> t option -> string option
           end) (X : sig
                       val option_name : string
                       val help : string
                       val arg_name : string
                       val default : V.t Datatype.String.Map.t
                     end->
      sig
        type key = string
        type value = V.t
        type t = V.t Datatype.String.Map.t
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = key * value option
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val set_default : t -> unit
            val add :
              string -> State.t list -> elt Parameter_category.accessor -> t
            val enable_all :
              State.t list -> elt Parameter_category.accessor -> t
            val enable_all_as : t -> unit
          end
        val find : key -> value
        val mem : key -> bool
      end
  module Kernel_function_map :
    functor
      (V : sig
             type t
             val ty : t Type.t
             val name : string
             val descr : t Descr.t
             val packed_descr : Structural_descr.pack
             val reprs : t list
             val equal : t -> t -> bool
             val compare : t -> t -> int
             val hash : t -> int
             val pretty_code : Format.formatter -> t -> unit
             val internal_pretty_code :
               Type.precedence -> Format.formatter -> t -> unit
             val pretty : Format.formatter -> t -> unit
             val varname : t -> string
             val mem_project : (Project_skeleton.t -> bool) -> t -> bool
             val copy : t -> t
             type key = Cil_types.kernel_function
             val of_string :
               key:key -> prev:t option -> string option -> t option
             val to_string : key:key -> t option -> string option
           end) (X : sig
                       val option_name : string
                       val help : string
                       val arg_name : string
                       val default : V.t Cil_datatype.Kf.Map.t
                     end->
      sig
        type key = Cil_types.kernel_function
        type value = V.t
        type t = V.t Cil_datatype.Kf.Map.t
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = key * value option
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val set_default : t -> unit
            val add :
              string -> State.t list -> elt Parameter_category.accessor -> t
            val enable_all :
              State.t list -> elt Parameter_category.accessor -> t
            val enable_all_as : t -> unit
          end
        val find : key -> value
        val mem : key -> bool
      end
  module Make_multiple_map :
    functor
      (K : Parameter_sig.String_datatype_with_collections) (V : sig
                                                                  type t
                                                                  val ty :
                                                                    t Type.t
                                                                  val name :
                                                                    string
                                                                  val descr :
                                                                    t Descr.t
                                                                  val packed_descr :
                                                                    Structural_descr.pack
                                                                  val reprs :
                                                                    t list
                                                                  val equal :
                                                                    t ->
                                                                    t -> bool
                                                                  val compare :
                                                                    t ->
                                                                    t -> int
                                                                  val hash :
                                                                    t -> int
                                                                  val pretty_code :
                                                                    Format.formatter ->
                                                                    t -> unit
                                                                  val internal_pretty_code :
                                                                    Type.precedence ->
                                                                    Format.formatter ->
                                                                    t -> unit
                                                                  val pretty :
                                                                    Format.formatter ->
                                                                    t -> unit
                                                                  val varname :
                                                                    t ->
                                                                    string
                                                                  val mem_project :
                                                                    (Project_skeleton.t ->
                                                                    bool) ->
                                                                    t -> bool
                                                                  val copy :
                                                                    t -> t
                                                                  type key =
                                                                    K.t
                                                                  val of_string :
                                                                    key:
                                                                    key ->
                                                                    prev:
                                                                    t list
                                                                    option ->
                                                                    string
                                                                    option ->
                                                                    t option
                                                                  val to_string :
                                                                    key:
                                                                    key ->
                                                                    t option ->
                                                                    string
                                                                    option
                                                                end) (X : 
      sig
        val option_name : string
        val help : string
        val arg_name : string
        val default : V.t list K.Map.t
      end->
      sig
        type key = K.t
        type value = V.t
        type t = V.t list K.Map.t
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = key * value list
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val set_default : t -> unit
            val add :
              string -> State.t list -> elt Parameter_category.accessor -> t
            val enable_all :
              State.t list -> elt Parameter_category.accessor -> t
            val enable_all_as : t -> unit
          end
        val find : key -> value list
        val mem : key -> bool
      end
  module String_multiple_map :
    functor
      (V : sig
             type t
             val ty : t Type.t
             val name : string
             val descr : t Descr.t
             val packed_descr : Structural_descr.pack
             val reprs : t list
             val equal : t -> t -> bool
             val compare : t -> t -> int
             val hash : t -> int
             val pretty_code : Format.formatter -> t -> unit
             val internal_pretty_code :
               Type.precedence -> Format.formatter -> t -> unit
             val pretty : Format.formatter -> t -> unit
             val varname : t -> string
             val mem_project : (Project_skeleton.t -> bool) -> t -> bool
             val copy : t -> t
             type key = string
             val of_string :
               key:key -> prev:t list option -> string option -> t option
             val to_string : key:key -> t option -> string option
           end) (X : sig
                       val option_name : string
                       val help : string
                       val arg_name : string
                       val default : V.t list Datatype.String.Map.t
                     end->
      sig
        type key = string
        type value = V.t
        type t = V.t list Datatype.String.Map.t
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = key * value list
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val set_default : t -> unit
            val add :
              string -> State.t list -> elt Parameter_category.accessor -> t
            val enable_all :
              State.t list -> elt Parameter_category.accessor -> t
            val enable_all_as : t -> unit
          end
        val find : key -> value list
        val mem : key -> bool
      end
  module Kernel_function_multiple_map :
    functor
      (V : sig
             type t
             val ty : t Type.t
             val name : string
             val descr : t Descr.t
             val packed_descr : Structural_descr.pack
             val reprs : t list
             val equal : t -> t -> bool
             val compare : t -> t -> int
             val hash : t -> int
             val pretty_code : Format.formatter -> t -> unit
             val internal_pretty_code :
               Type.precedence -> Format.formatter -> t -> unit
             val pretty : Format.formatter -> t -> unit
             val varname : t -> string
             val mem_project : (Project_skeleton.t -> bool) -> t -> bool
             val copy : t -> t
             type key = Cil_types.kernel_function
             val of_string :
               key:key -> prev:t list option -> string option -> t option
             val to_string : key:key -> t option -> string option
           end) (X : sig
                       val option_name : string
                       val help : string
                       val arg_name : string
                       val default : V.t list Cil_datatype.Kf.Map.t
                     end->
      sig
        type key = Cil_types.kernel_function
        type value = V.t
        type t = V.t list Cil_datatype.Kf.Map.t
        val set : t -> unit
        val add_set_hook : (t -> t -> unit) -> unit
        val add_update_hook : (t -> t -> unit) -> unit
        val get : unit -> t
        val clear : unit -> unit
        val is_default : unit -> bool
        val option_name : string
        val print_help : Format.formatter -> unit
        val self : State.t
        val name : string
        val mark_as_computed : ?project:Project.t -> unit -> unit
        val is_computed : ?project:Project.t -> unit -> bool
        module Datatype : Datatype.S
        val add_hook_on_update : (Datatype.t -> unit) -> unit
        val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
        val equal : t -> t -> bool
        val add_aliases : string list -> unit
        val is_set : unit -> bool
        val unsafe_set : t -> unit
        val parameter : Typed_parameter.t
        type elt = key * value list
        val is_empty : unit -> bool
        val iter : (elt -> unit) -> unit
        val fold : (elt -> '-> 'a) -> '-> 'a
        val add : elt -> unit
        module As_string : Parameter_sig.String
        module Category :
          sig
            type elt = elt
            type t = elt Parameter_category.t
            val none : t
            val default : unit -> t
            val 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
  module Enabled : Parameter_sig.Bool
  module PrintProperties : Parameter_sig.Bool
  module Untried : Parameter_sig.Bool
  module Specialized : Parameter_sig.Bool
  module Proven : Parameter_sig.Bool
  module CSVFile : Parameter_sig.String
end