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