/*
 * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
// Autogenerated file -- DO NOT EDIT!

#ifndef PANDA_RUNTIME_OPTIONS_GEN_H
#define PANDA_RUNTIME_OPTIONS_GEN_H

#include "libarkbase/utils/pandargs.h"
#include "platforms/target_defaults/default_target_options.h"
#include "libarkbase/macros.h"

#include <optional>
#include <string>
#include <unordered_set>
#include <vector>

namespace ark {
// NOLINTBEGIN(readability-identifier-naming,readability-magic-numbers)
class PANDA_PUBLIC_API Options {
public:
    class Error {
    public:
        explicit Error(std::string msg) : msg_(std::move(msg)) {}

        std::string GetMessage() {
            return msg_;
        }
    private:
        std::string msg_;
    };

    explicit Options(const std::string &exe_path) :
        exe_dir_(GetExeDir(exe_path))
        ,gc_workers_count_{"gc-workers-count", ark::default_target_options::GetTargetSpecificOptionValue<std::map<std::string, uint32_t>>(std::map<std::string, uint32_t>{{R"(HL1CMSM)", 2},{R"(ohos)", 2},{R"(HN1NOAHM)", 2},{R"(default)", 2},}, ark::default_target_options::GetTargetString), R"(Set number of additional GC helper threads. GC uses these threads to speed up collection doing work in parallel. Default (target specific):
 on 'HL1CMSM': 2
 on 'ohos': 2
 on 'HN1NOAHM': 2
 on 'default': 2
)"}
        ,internal_memory_size_limit_{"internal-memory-size-limit", ark::default_target_options::GetTargetSpecificOptionValue<std::map<std::string, uint64_t>>(std::map<std::string, uint64_t>{{R"(arm32)", 2147483648},{R"(default)", 8589934592},}, ark::default_target_options::GetTargetString), R"(Max internal memory used by the VM. Default (target specific):
 on 'arm32': 2147483648
 on 'default': 8589934592
)"}
        ,coroutines_stack_mem_limit_{"coroutines-stack-mem-limit", ark::default_target_options::GetTargetSpecificOptionValue<std::map<std::string, uint64_t>>(std::map<std::string, uint64_t>{{R"(arm32)", 536870912},{R"(default)", 4194304000},}, ark::default_target_options::GetTargetString), R"(defines the total amount of memory that can be used for stackful coroutine stacks allocation (in bytes). Default (target specific):
 on 'arm32': 536870912
 on 'default': 4194304000
)"}
        ,taskmanager_workers_count_{"taskmanager-workers-count", ark::default_target_options::GetTargetSpecificOptionValue<std::map<std::string, uint32_t>>(std::map<std::string, uint32_t>{{R"(HL1CMSM)", 3},{R"(ohos)", 2},{R"(HN1NOAHM)", 4},{R"(default)", 4},}, ark::default_target_options::GetTargetString), R"(Number of worker threads for the taskmanager. Option is used only for --worker-type=taskmanager. Default (target specific):
 on 'HL1CMSM': 3
 on 'ohos': 2
 on 'HN1NOAHM': 4
 on 'default': 4
)"}
    {}

    // NOLINTBEGIN(readability-function-size)
    void AddOptions(PandArgParser *parser) {
        parser->Add(&version_);
        parser->Add(&boot_panda_files_);
        parser->Add(&panda_files_);
        parser->Add(&boot_intrinsic_spaces_);
        parser->Add(&boot_class_spaces_);
        parser->Add(&runtime_type_);
        parser->Add(&load_runtimes_);
        parser->Add(&runtime_compressed_strings_enabled_);
        parser->Add(&explicit_concurrent_gc_enabled_);
        parser->Add(&ets_run_gc_in_place_);
        parser->Add(&run_gc_in_place_);
        parser->Add(&full_gc_bombing_frequency_);
        parser->Add(&run_gc_every_safepoint_);
        parser->Add(&compiler_enable_jit_);
        parser->Add(&compiler_hotness_threshold_);
        parser->Add(&compiler_profiling_threshold_);
        parser->Add(&compiler_enable_osr_);
        parser->Add(&debugger_library_path_);
        parser->Add(&debugger_enable_);
        parser->Add(&sampling_profiler_create_);
        parser->Add(&profile_branches_);
        parser->Add(&sampling_profiler_startup_run_);
        parser->Add(&sampling_profiler_interval_);
        parser->Add(&sampling_profiler_output_file_);
        parser->Add(&debugger_port_);
        parser->Add(&debugger_break_on_start_);
        parser->Add(&compiler_nullcheck_);
        parser->Add(&reference_dump_);
        parser->Add(&signal_catcher_);
        parser->Add(&signal_handler_);
        parser->Add(&sigquit_flag_);
        parser->Add(&sigusr1_flag_);
        parser->Add(&sigusr2_flag_);
        parser->Add(&mobile_log_flag_);
        parser->Add(&dfx_log_);
        parser->Add(&ets_gc_type_);
        parser->Add(&gc_type_);
        parser->Add(&ic_enable_);
        parser->Add(&ets_gc_trigger_type_);
        parser->Add(&gc_trigger_type_);
        parser->Add(&log_detailed_gc_info_enabled_);
        parser->Add(&log_detailed_gc_compaction_info_enabled_);
        parser->Add(&gc_trigger_percent_threshold_);
        parser->Add(&gc_trigger_adaptive_multiplier_);
        parser->Add(&max_trigger_percent_);
        parser->Add(&ets_skip_startup_gc_count_);
        parser->Add(&skip_startup_gc_count_);
        parser->Add(&gc_use_nth_alloc_trigger_);
        parser->Add(&init_young_space_size_);
        parser->Add(&young_space_size_);
        parser->Add(&young_shared_space_size_);
        parser->Add(&min_extra_heap_size_);
        parser->Add(&max_extra_heap_size_);
        parser->Add(&ets_gc_debug_trigger_start_);
        parser->Add(&gc_debug_trigger_start_);
        parser->Add(&ets_gc_dump_heap_);
        parser->Add(&gc_dump_heap_);
        parser->Add(&gc_workers_count_);
        parser->Add(&manage_gc_threads_affinity_);
        parser->Add(&use_weak_cpu_for_gc_concurrent_);
        parser->Add(&g1_region_garbage_rate_threshold_);
        parser->Add(&g1_number_of_tenured_regions_at_mixed_collection_);
        parser->Add(&g1_track_freed_objects_);
        parser->Add(&gc_marking_stack_new_tasks_frequency_);
        parser->Add(&gc_root_marking_stack_max_size_);
        parser->Add(&gc_workers_marking_stack_max_size_);
        parser->Add(&gc_parallel_marking_enabled_);
        parser->Add(&gc_parallel_compacting_enabled_);
        parser->Add(&gc_parallel_ref_updating_enabled_);
        parser->Add(&long_gc_threshold_ns_);
        parser->Add(&g1_single_pass_compaction_enabled_);
        parser->Add(&reference_processor_enable_);
        parser->Add(&ets_gc_enable_tracing_);
        parser->Add(&gc_enable_tracing_);
        parser->Add(&g1_enable_concurrent_update_remset_);
        parser->Add(&g1_min_concurrent_cards_to_process_);
        parser->Add(&g1_hot_cards_processing_frequency_);
        parser->Add(&g1_promotion_region_alive_rate_);
        parser->Add(&g1_full_gc_region_fragmentation_rate_);
        parser->Add(&g1_pause_time_goal_);
        parser->Add(&distributed_profiling_);
        parser->Add(&aot_file_);
        parser->Add(&aot_files_);
        parser->Add(&aot_verify_abs_path_);
        parser->Add(&adaptive_tlab_size_);
        parser->Add(&init_tlab_size_);
        parser->Add(&max_tlab_size_);
        parser->Add(&use_tlab_for_allocations_);
        parser->Add(&init_heap_size_limit_);
        parser->Add(&heap_size_limit_);
        parser->Add(&internal_memory_size_limit_);
        parser->Add(&frames_memory_size_limit_);
        parser->Add(&min_heap_free_percentage_);
        parser->Add(&max_heap_free_percentage_);
        parser->Add(&code_cache_size_limit_);
        parser->Add(&compiler_memory_size_limit_);
        parser->Add(&print_memory_statistics_);
        parser->Add(&print_gc_statistics_);
        parser->Add(&no_async_jit_);
        parser->Add(&compiler_queue_type_);
        parser->Add(&compiler_task_life_span_);
        parser->Add(&compiler_queue_max_length_);
        parser->Add(&compiler_epoch_duration_);
        parser->Add(&compiler_death_counter_value_);
        parser->Add(&limit_standard_alloc_);
        parser->Add(&internal_allocator_type_);
        parser->Add(&finalizer_timeout_ms_);
        parser->Add(&properties_);
        parser->Add(&events_output_);
        parser->Add(&events_file_);
        parser->Add(&mem_alloc_dump_exec_);
        parser->Add(&mem_alloc_dump_file_);
        parser->Add(&startup_time_);
        parser->Add(&max_free_);
        parser->Add(&ets_native_gc_trigger_type_);
        parser->Add(&native_gc_trigger_type_);
        parser->Add(&profiler_enabled_);
        parser->Add(&profilesaver_sleeping_time_ms_);
        parser->Add(&profilesaver_delta_number_threshold_);
        parser->Add(&profilesaver_enabled_);
        parser->Add(&incremental_profilesaver_enabled_);
        parser->Add(&start_as_zygote_);
        parser->Add(&verification_mode_);
        parser->Add(&verification_update_cache_);
        parser->Add(&verification_threads_);
        parser->Add(&verification_config_file_);
        parser->Add(&verification_cache_file_);
        parser->Add(&ets_enable_fast_heap_verifier_);
        parser->Add(&enable_fast_heap_verifier_);
        parser->Add(&heap_verifier_);
        parser->Add(&max_global_ref_size_);
        parser->Add(&global_reference_size_check_enabled_);
        parser->Add(&ets_concurrent_gc_enabled_);
        parser->Add(&concurrent_gc_enabled_);
        parser->Add(&snapshot_serialize_enabled_);
        parser->Add(&snapshot_deserialize_enabled_);
        parser->Add(&snapshot_file_);
        parser->Add(&framework_abc_file_);
        parser->Add(&boot_an_location_);
        parser->Add(&enable_an_);
        parser->Add(&verify_call_stack_);
        parser->Add(&safepoint_backtrace_);
        parser->Add(&aot_string_gc_roots_limit_);
        parser->Add(&resolve_string_aot_threshold_);
        parser->Add(&icu_data_path_);
        parser->Add(&ark_aot_);
        parser->Add(&intrinsics_blacklist_);
        parser->Add(&verify_entrypoints_);
        parser->Add(&ignore_daemon_memory_leaks_threshold_);
        parser->Add(&interpreter_type_);
        parser->Add(&abc_layout_profile_location_);
        parser->Add(&intrusive_test_);
        parser->Add(&profile_output_);
        parser->Add(&call_profiling_table_size_);
        parser->Add(&coroutine_stack_size_pages_);
        parser->Add(&coroutines_stack_mem_limit_);
        parser->Add(&coroutines_user_limit_);
        parser->Add(&use_coroutine_pool_);
        parser->Add(&workers_type_);
        parser->Add(&taskmanager_workers_count_);
        parser->Add(&task_stats_type_);
        parser->Add(&load_in_boot_);
        parser->Add(&use_string_caches_);
        parser->Add(&use_all_strings_);
        parser->Add(&code_coverage_enabled_);
        parser->Add(&code_coverage_output_);
        parser->Add(&use_boot_class_filter_);
        parser->Add(&enable_class_linker_trace_);
        parser->Add(&xgc_min_trigger_threshold_);
        parser->Add(&xgc_trigger_percent_threshold_);
        parser->Add(&ets_xgc_trigger_type_);
        parser->Add(&xgc_trigger_type_);
        parser->Add(&enable_xgc_verifier_);
        parser->Add(&ets_taskpool_support_interop_);
        parser->Add(&taskpool_support_interop_);
        parser->Add(&ets_fail_on_heap_verification_);
        parser->Add(&fail_on_heap_verification_);
        parser->Add(&ets_pre_gc_heap_verify_enabled_);
        parser->Add(&pre_gc_heap_verify_enabled_);
        parser->Add(&ets_into_gc_heap_verify_enabled_);
        parser->Add(&into_gc_heap_verify_enabled_);
        parser->Add(&ets_post_gc_heap_verify_enabled_);
        parser->Add(&post_gc_heap_verify_enabled_);
        parser->Add(&ets_enable_paralled_young_gc_);
        parser->Add(&enable_paralled_young_gc_);
        parser->Add(&ets_coroutine_impl_);
        parser->Add(&coroutine_impl_);
        parser->Add(&ets_coroutine_workers_count_);
        parser->Add(&coroutine_workers_count_);
        parser->Add(&ets_coroutine_e_workers_limit_);
        parser->Add(&coroutine_e_workers_limit_);
        parser->Add(&coroutine_enable_features_);
        parser->Add(&ets_coroutine_dump_stats_);
        parser->Add(&coroutine_dump_stats_);
        parser->Add(&ets_taskpool_mode_);
        parser->Add(&taskpool_mode_);
        parser->Add(&ets_native_library_path_);
        parser->Add(&native_library_path_);
        parser->Add(&list_unhandled_on_exit_);
    }
    // NOLINTEND(readability-function-size)

    bool IsVersion([[maybe_unused]] std::string_view lang = "") const {
        return version_.GetValue();
    }

    void SetVersion(bool value) {
        version_.SetValue(value);
    }

    bool WasSetVersion([[maybe_unused]] std::string_view lang = "") const {
        return version_.WasSet();
    }
    const arg_list_t &GetBootPandaFiles([[maybe_unused]] std::string_view lang = "") const {
        return boot_panda_files_.GetValue();
    }

    void SetBootPandaFiles(arg_list_t value) {
        boot_panda_files_.SetValue(std::move(value));
    }

    bool WasSetBootPandaFiles([[maybe_unused]] std::string_view lang = "") const {
        return boot_panda_files_.WasSet();
    }
    const arg_list_t &GetPandaFiles([[maybe_unused]] std::string_view lang = "") const {
        return panda_files_.GetValue();
    }

    void SetPandaFiles(arg_list_t value) {
        panda_files_.SetValue(std::move(value));
    }

    bool WasSetPandaFiles([[maybe_unused]] std::string_view lang = "") const {
        return panda_files_.WasSet();
    }
    const arg_list_t &GetBootIntrinsicSpaces([[maybe_unused]] std::string_view lang = "") const {
        return boot_intrinsic_spaces_.GetValue();
    }

    void SetBootIntrinsicSpaces(arg_list_t value) {
        boot_intrinsic_spaces_.SetValue(std::move(value));
    }

    bool WasSetBootIntrinsicSpaces([[maybe_unused]] std::string_view lang = "") const {
        return boot_intrinsic_spaces_.WasSet();
    }
    const arg_list_t &GetBootClassSpaces([[maybe_unused]] std::string_view lang = "") const {
        return boot_class_spaces_.GetValue();
    }

    void SetBootClassSpaces(arg_list_t value) {
        boot_class_spaces_.SetValue(std::move(value));
    }

    bool WasSetBootClassSpaces([[maybe_unused]] std::string_view lang = "") const {
        return boot_class_spaces_.WasSet();
    }
    const std::string &GetRuntimeType([[maybe_unused]] std::string_view lang = "") const {
        return runtime_type_.GetValue();
    }

    void SetRuntimeType(std::string value) {
        runtime_type_.SetValue(std::move(value));
    }

    bool WasSetRuntimeType([[maybe_unused]] std::string_view lang = "") const {
        return runtime_type_.WasSet();
    }
    const arg_list_t &GetLoadRuntimes([[maybe_unused]] std::string_view lang = "") const {
        return load_runtimes_.GetValue();
    }

    void SetLoadRuntimes(arg_list_t value) {
        load_runtimes_.SetValue(std::move(value));
    }

    bool WasSetLoadRuntimes([[maybe_unused]] std::string_view lang = "") const {
        return load_runtimes_.WasSet();
    }
    bool IsRuntimeCompressedStringsEnabled([[maybe_unused]] std::string_view lang = "") const {
        return runtime_compressed_strings_enabled_.GetValue();
    }

    void SetRuntimeCompressedStringsEnabled(bool value) {
        runtime_compressed_strings_enabled_.SetValue(value);
    }

    bool WasSetRuntimeCompressedStringsEnabled([[maybe_unused]] std::string_view lang = "") const {
        return runtime_compressed_strings_enabled_.WasSet();
    }
    bool IsExplicitConcurrentGcEnabled([[maybe_unused]] std::string_view lang = "") const {
        return explicit_concurrent_gc_enabled_.GetValue();
    }

    void SetExplicitConcurrentGcEnabled(bool value) {
        explicit_concurrent_gc_enabled_.SetValue(value);
    }

    bool WasSetExplicitConcurrentGcEnabled([[maybe_unused]] std::string_view lang = "") const {
        return explicit_concurrent_gc_enabled_.WasSet();
    }
    bool IsRunGcInPlace([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsRunGcInPlace() ? ets_run_gc_in_place_.GetValue() : run_gc_in_place_.GetValue();
        }
        return run_gc_in_place_.GetValue();
    }

    void SetRunGcInPlace(bool value) {
        run_gc_in_place_.SetValue(value);
    }

    bool WasSetRunGcInPlace(std::string_view lang) const {
        if (lang == "ets") {
            return ets_run_gc_in_place_.WasSet();
        }
        return run_gc_in_place_.WasSet();
    }
    uint32_t GetFullGcBombingFrequency([[maybe_unused]] std::string_view lang = "") const {
        return full_gc_bombing_frequency_.GetValue();
    }

    void SetFullGcBombingFrequency(uint32_t value) {
        full_gc_bombing_frequency_.SetValue(value);
    }

    bool WasSetFullGcBombingFrequency([[maybe_unused]] std::string_view lang = "") const {
        return full_gc_bombing_frequency_.WasSet();
    }
    bool IsRunGcEverySafepoint([[maybe_unused]] std::string_view lang = "") const {
        return run_gc_every_safepoint_.GetValue();
    }

    void SetRunGcEverySafepoint(bool value) {
        run_gc_every_safepoint_.SetValue(value);
    }

    bool WasSetRunGcEverySafepoint([[maybe_unused]] std::string_view lang = "") const {
        return run_gc_every_safepoint_.WasSet();
    }
    bool IsCompilerEnableJit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_jit_.GetValue();
    }

    void SetCompilerEnableJit(bool value) {
        compiler_enable_jit_.SetValue(value);
    }

    bool WasSetCompilerEnableJit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_jit_.WasSet();
    }
    uint32_t GetCompilerHotnessThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_hotness_threshold_.GetValue();
    }

    void SetCompilerHotnessThreshold(uint32_t value) {
        compiler_hotness_threshold_.SetValue(value);
    }

    bool WasSetCompilerHotnessThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_hotness_threshold_.WasSet();
    }
    uint32_t GetCompilerProfilingThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_profiling_threshold_.GetValue();
    }

    void SetCompilerProfilingThreshold(uint32_t value) {
        compiler_profiling_threshold_.SetValue(value);
    }

    bool WasSetCompilerProfilingThreshold([[maybe_unused]] std::string_view lang = "") const {
        return compiler_profiling_threshold_.WasSet();
    }
    bool IsCompilerEnableOsr([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_osr_.GetValue();
    }

    void SetCompilerEnableOsr(bool value) {
        compiler_enable_osr_.SetValue(value);
    }

    bool WasSetCompilerEnableOsr([[maybe_unused]] std::string_view lang = "") const {
        return compiler_enable_osr_.WasSet();
    }
    const std::string &GetDebuggerLibraryPath([[maybe_unused]] std::string_view lang = "") const {
        return debugger_library_path_.GetValue();
    }

    void SetDebuggerLibraryPath(std::string value) {
        debugger_library_path_.SetValue(std::move(value));
    }

    bool WasSetDebuggerLibraryPath([[maybe_unused]] std::string_view lang = "") const {
        return debugger_library_path_.WasSet();
    }
    bool IsDebuggerEnable([[maybe_unused]] std::string_view lang = "") const {
        return debugger_enable_.GetValue();
    }

    void SetDebuggerEnable(bool value) {
        debugger_enable_.SetValue(value);
    }

    bool WasSetDebuggerEnable([[maybe_unused]] std::string_view lang = "") const {
        return debugger_enable_.WasSet();
    }
    bool IsSamplingProfilerCreate([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_create_.GetValue();
    }

    void SetSamplingProfilerCreate(bool value) {
        sampling_profiler_create_.SetValue(value);
    }

    bool WasSetSamplingProfilerCreate([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_create_.WasSet();
    }
    bool IsProfileBranches([[maybe_unused]] std::string_view lang = "") const {
        return profile_branches_.GetValue();
    }

    void SetProfileBranches(bool value) {
        profile_branches_.SetValue(value);
    }

    bool WasSetProfileBranches([[maybe_unused]] std::string_view lang = "") const {
        return profile_branches_.WasSet();
    }
    bool IsSamplingProfilerStartupRun([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_startup_run_.GetValue();
    }

    void SetSamplingProfilerStartupRun(bool value) {
        sampling_profiler_startup_run_.SetValue(value);
    }

    bool WasSetSamplingProfilerStartupRun([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_startup_run_.WasSet();
    }
    uint32_t GetSamplingProfilerInterval([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_interval_.GetValue();
    }

    void SetSamplingProfilerInterval(uint32_t value) {
        sampling_profiler_interval_.SetValue(value);
    }

    bool WasSetSamplingProfilerInterval([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_interval_.WasSet();
    }
    const std::string &GetSamplingProfilerOutputFile([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_output_file_.GetValue();
    }

    void SetSamplingProfilerOutputFile(std::string value) {
        sampling_profiler_output_file_.SetValue(std::move(value));
    }

    bool WasSetSamplingProfilerOutputFile([[maybe_unused]] std::string_view lang = "") const {
        return sampling_profiler_output_file_.WasSet();
    }
    uint32_t GetDebuggerPort([[maybe_unused]] std::string_view lang = "") const {
        return debugger_port_.GetValue();
    }

    void SetDebuggerPort(uint32_t value) {
        debugger_port_.SetValue(value);
    }

    bool WasSetDebuggerPort([[maybe_unused]] std::string_view lang = "") const {
        return debugger_port_.WasSet();
    }
    bool IsDebuggerBreakOnStart([[maybe_unused]] std::string_view lang = "") const {
        return debugger_break_on_start_.GetValue();
    }

    void SetDebuggerBreakOnStart(bool value) {
        debugger_break_on_start_.SetValue(value);
    }

    bool WasSetDebuggerBreakOnStart([[maybe_unused]] std::string_view lang = "") const {
        return debugger_break_on_start_.WasSet();
    }
    const arg_list_t &GetLogComponents([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-components' is deprecated and should not be used\n";
        return log_components_.GetValue();
    }

    void SetLogComponents(arg_list_t value) {
        std::cerr << "WARNING: Option 'log-components' is deprecated and should not be used\n";
        log_components_.SetValue(std::move(value));
    }

    bool WasSetLogComponents([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-components' is deprecated and should not be used\n";
        return log_components_.WasSet();
    }
    uint64_t GetCompilerNullcheck([[maybe_unused]] std::string_view lang = "") const {
        return compiler_nullcheck_.GetValue();
    }

    void SetCompilerNullcheck(uint64_t value) {
        compiler_nullcheck_.SetValue(value);
    }

    bool WasSetCompilerNullcheck([[maybe_unused]] std::string_view lang = "") const {
        return compiler_nullcheck_.WasSet();
    }
    uint64_t GetReferenceDump([[maybe_unused]] std::string_view lang = "") const {
        return reference_dump_.GetValue();
    }

    void SetReferenceDump(uint64_t value) {
        reference_dump_.SetValue(value);
    }

    bool WasSetReferenceDump([[maybe_unused]] std::string_view lang = "") const {
        return reference_dump_.WasSet();
    }
    uint64_t GetSignalCatcher([[maybe_unused]] std::string_view lang = "") const {
        return signal_catcher_.GetValue();
    }

    void SetSignalCatcher(uint64_t value) {
        signal_catcher_.SetValue(value);
    }

    bool WasSetSignalCatcher([[maybe_unused]] std::string_view lang = "") const {
        return signal_catcher_.WasSet();
    }
    uint64_t GetSignalHandler([[maybe_unused]] std::string_view lang = "") const {
        return signal_handler_.GetValue();
    }

    void SetSignalHandler(uint64_t value) {
        signal_handler_.SetValue(value);
    }

    bool WasSetSignalHandler([[maybe_unused]] std::string_view lang = "") const {
        return signal_handler_.WasSet();
    }
    uint64_t GetSigquitFlag([[maybe_unused]] std::string_view lang = "") const {
        return sigquit_flag_.GetValue();
    }

    void SetSigquitFlag(uint64_t value) {
        sigquit_flag_.SetValue(value);
    }

    bool WasSetSigquitFlag([[maybe_unused]] std::string_view lang = "") const {
        return sigquit_flag_.WasSet();
    }
    uint64_t GetSigusr1Flag([[maybe_unused]] std::string_view lang = "") const {
        return sigusr1_flag_.GetValue();
    }

    void SetSigusr1Flag(uint64_t value) {
        sigusr1_flag_.SetValue(value);
    }

    bool WasSetSigusr1Flag([[maybe_unused]] std::string_view lang = "") const {
        return sigusr1_flag_.WasSet();
    }
    uint64_t GetSigusr2Flag([[maybe_unused]] std::string_view lang = "") const {
        return sigusr2_flag_.GetValue();
    }

    void SetSigusr2Flag(uint64_t value) {
        sigusr2_flag_.SetValue(value);
    }

    bool WasSetSigusr2Flag([[maybe_unused]] std::string_view lang = "") const {
        return sigusr2_flag_.WasSet();
    }
    uint64_t GetMobileLogFlag([[maybe_unused]] std::string_view lang = "") const {
        return mobile_log_flag_.GetValue();
    }

    void SetMobileLogFlag(uint64_t value) {
        mobile_log_flag_.SetValue(value);
    }

    bool WasSetMobileLogFlag([[maybe_unused]] std::string_view lang = "") const {
        return mobile_log_flag_.WasSet();
    }
    uint64_t GetDfxLog([[maybe_unused]] std::string_view lang = "") const {
        return dfx_log_.GetValue();
    }

    void SetDfxLog(uint64_t value) {
        dfx_log_.SetValue(value);
    }

    bool WasSetDfxLog([[maybe_unused]] std::string_view lang = "") const {
        return dfx_log_.WasSet();
    }
    const std::string &GetGcType([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsGcType() ? ets_gc_type_.GetValue() : gc_type_.GetValue();
        }
        return gc_type_.GetValue();
    }

    void SetGcType(std::string value) {
        gc_type_.SetValue(std::move(value));
    }

    bool WasSetGcType(std::string_view lang) const {
        if (lang == "ets") {
            return ets_gc_type_.WasSet();
        }
        return gc_type_.WasSet();
    }
    bool IsIcEnable([[maybe_unused]] std::string_view lang = "") const {
        return ic_enable_.GetValue();
    }

    void SetIcEnable(bool value) {
        ic_enable_.SetValue(value);
    }

    bool WasSetIcEnable([[maybe_unused]] std::string_view lang = "") const {
        return ic_enable_.WasSet();
    }
    const std::string &GetGcTriggerType([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsGcTriggerType() ? ets_gc_trigger_type_.GetValue() : gc_trigger_type_.GetValue();
        }
        return gc_trigger_type_.GetValue();
    }

    void SetGcTriggerType(std::string value) {
        gc_trigger_type_.SetValue(std::move(value));
    }

    bool WasSetGcTriggerType(std::string_view lang) const {
        if (lang == "ets") {
            return ets_gc_trigger_type_.WasSet();
        }
        return gc_trigger_type_.WasSet();
    }
    bool IsLogDetailedGcInfoEnabled([[maybe_unused]] std::string_view lang = "") const {
        return log_detailed_gc_info_enabled_.GetValue();
    }

    void SetLogDetailedGcInfoEnabled(bool value) {
        log_detailed_gc_info_enabled_.SetValue(value);
    }

    bool WasSetLogDetailedGcInfoEnabled([[maybe_unused]] std::string_view lang = "") const {
        return log_detailed_gc_info_enabled_.WasSet();
    }
    bool IsLogDetailedGcCompactionInfoEnabled([[maybe_unused]] std::string_view lang = "") const {
        return log_detailed_gc_compaction_info_enabled_.GetValue();
    }

    void SetLogDetailedGcCompactionInfoEnabled(bool value) {
        log_detailed_gc_compaction_info_enabled_.SetValue(value);
    }

    bool WasSetLogDetailedGcCompactionInfoEnabled([[maybe_unused]] std::string_view lang = "") const {
        return log_detailed_gc_compaction_info_enabled_.WasSet();
    }
    uint32_t GetGcTriggerPercentThreshold([[maybe_unused]] std::string_view lang = "") const {
        return gc_trigger_percent_threshold_.GetValue();
    }

    void SetGcTriggerPercentThreshold(uint32_t value) {
        gc_trigger_percent_threshold_.SetValue(value);
    }

    bool WasSetGcTriggerPercentThreshold([[maybe_unused]] std::string_view lang = "") const {
        return gc_trigger_percent_threshold_.WasSet();
    }
    uint32_t GetGcTriggerAdaptiveMultiplier([[maybe_unused]] std::string_view lang = "") const {
        return gc_trigger_adaptive_multiplier_.GetValue();
    }

    void SetGcTriggerAdaptiveMultiplier(uint32_t value) {
        gc_trigger_adaptive_multiplier_.SetValue(value);
    }

    bool WasSetGcTriggerAdaptiveMultiplier([[maybe_unused]] std::string_view lang = "") const {
        return gc_trigger_adaptive_multiplier_.WasSet();
    }
    uint32_t GetMaxTriggerPercent([[maybe_unused]] std::string_view lang = "") const {
        return max_trigger_percent_.GetValue();
    }

    void SetMaxTriggerPercent(uint32_t value) {
        max_trigger_percent_.SetValue(value);
    }

    bool WasSetMaxTriggerPercent([[maybe_unused]] std::string_view lang = "") const {
        return max_trigger_percent_.WasSet();
    }
    uint32_t GetSkipStartupGcCount([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsSkipStartupGcCount() ? ets_skip_startup_gc_count_.GetValue() : skip_startup_gc_count_.GetValue();
        }
        return skip_startup_gc_count_.GetValue();
    }

    void SetSkipStartupGcCount(uint32_t value) {
        skip_startup_gc_count_.SetValue(value);
    }

    bool WasSetSkipStartupGcCount(std::string_view lang) const {
        if (lang == "ets") {
            return ets_skip_startup_gc_count_.WasSet();
        }
        return skip_startup_gc_count_.WasSet();
    }
    bool IsGcUseNthAllocTrigger([[maybe_unused]] std::string_view lang = "") const {
        return gc_use_nth_alloc_trigger_.GetValue();
    }

    void SetGcUseNthAllocTrigger(bool value) {
        gc_use_nth_alloc_trigger_.SetValue(value);
    }

    bool WasSetGcUseNthAllocTrigger([[maybe_unused]] std::string_view lang = "") const {
        return gc_use_nth_alloc_trigger_.WasSet();
    }
    uint64_t GetInitYoungSpaceSize([[maybe_unused]] std::string_view lang = "") const {
        return init_young_space_size_.GetValue();
    }

    void SetInitYoungSpaceSize(uint64_t value) {
        init_young_space_size_.SetValue(value);
    }

    bool WasSetInitYoungSpaceSize([[maybe_unused]] std::string_view lang = "") const {
        return init_young_space_size_.WasSet();
    }
    uint64_t GetYoungSpaceSize([[maybe_unused]] std::string_view lang = "") const {
        return young_space_size_.GetValue();
    }

    void SetYoungSpaceSize(uint64_t value) {
        young_space_size_.SetValue(value);
    }

    bool WasSetYoungSpaceSize([[maybe_unused]] std::string_view lang = "") const {
        return young_space_size_.WasSet();
    }
    uint64_t GetYoungSharedSpaceSize([[maybe_unused]] std::string_view lang = "") const {
        return young_shared_space_size_.GetValue();
    }

    void SetYoungSharedSpaceSize(uint64_t value) {
        young_shared_space_size_.SetValue(value);
    }

    bool WasSetYoungSharedSpaceSize([[maybe_unused]] std::string_view lang = "") const {
        return young_shared_space_size_.WasSet();
    }
    uint64_t GetMinExtraHeapSize([[maybe_unused]] std::string_view lang = "") const {
        return min_extra_heap_size_.GetValue();
    }

    void SetMinExtraHeapSize(uint64_t value) {
        min_extra_heap_size_.SetValue(value);
    }

    bool WasSetMinExtraHeapSize([[maybe_unused]] std::string_view lang = "") const {
        return min_extra_heap_size_.WasSet();
    }
    uint64_t GetMaxExtraHeapSize([[maybe_unused]] std::string_view lang = "") const {
        return max_extra_heap_size_.GetValue();
    }

    void SetMaxExtraHeapSize(uint64_t value) {
        max_extra_heap_size_.SetValue(value);
    }

    bool WasSetMaxExtraHeapSize([[maybe_unused]] std::string_view lang = "") const {
        return max_extra_heap_size_.WasSet();
    }
    uint64_t GetGcDebugTriggerStart([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsGcDebugTriggerStart() ? ets_gc_debug_trigger_start_.GetValue() : gc_debug_trigger_start_.GetValue();
        }
        return gc_debug_trigger_start_.GetValue();
    }

    void SetGcDebugTriggerStart(uint64_t value) {
        gc_debug_trigger_start_.SetValue(value);
    }

    bool WasSetGcDebugTriggerStart(std::string_view lang) const {
        if (lang == "ets") {
            return ets_gc_debug_trigger_start_.WasSet();
        }
        return gc_debug_trigger_start_.WasSet();
    }
    bool IsGcDumpHeap([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsGcDumpHeap() ? ets_gc_dump_heap_.GetValue() : gc_dump_heap_.GetValue();
        }
        return gc_dump_heap_.GetValue();
    }

    void SetGcDumpHeap(bool value) {
        gc_dump_heap_.SetValue(value);
    }

    bool WasSetGcDumpHeap(std::string_view lang) const {
        if (lang == "ets") {
            return ets_gc_dump_heap_.WasSet();
        }
        return gc_dump_heap_.WasSet();
    }
    uint32_t GetGcWorkersCount([[maybe_unused]] std::string_view lang = "") const {
        return gc_workers_count_.GetValue();
    }

    void SetGcWorkersCount(uint32_t value) {
        gc_workers_count_.SetValue(value);
    }

    bool WasSetGcWorkersCount([[maybe_unused]] std::string_view lang = "") const {
        return gc_workers_count_.WasSet();
    }
    bool IsManageGcThreadsAffinity([[maybe_unused]] std::string_view lang = "") const {
        return manage_gc_threads_affinity_.GetValue();
    }

    void SetManageGcThreadsAffinity(bool value) {
        manage_gc_threads_affinity_.SetValue(value);
    }

    bool WasSetManageGcThreadsAffinity([[maybe_unused]] std::string_view lang = "") const {
        return manage_gc_threads_affinity_.WasSet();
    }
    bool IsUseWeakCpuForGcConcurrent([[maybe_unused]] std::string_view lang = "") const {
        return use_weak_cpu_for_gc_concurrent_.GetValue();
    }

    void SetUseWeakCpuForGcConcurrent(bool value) {
        use_weak_cpu_for_gc_concurrent_.SetValue(value);
    }

    bool WasSetUseWeakCpuForGcConcurrent([[maybe_unused]] std::string_view lang = "") const {
        return use_weak_cpu_for_gc_concurrent_.WasSet();
    }
    uint32_t GetG1RegionGarbageRateThreshold([[maybe_unused]] std::string_view lang = "") const {
        return g1_region_garbage_rate_threshold_.GetValue();
    }

    void SetG1RegionGarbageRateThreshold(uint32_t value) {
        g1_region_garbage_rate_threshold_.SetValue(value);
    }

    bool WasSetG1RegionGarbageRateThreshold([[maybe_unused]] std::string_view lang = "") const {
        return g1_region_garbage_rate_threshold_.WasSet();
    }
    uint32_t GetG1NumberOfTenuredRegionsAtMixedCollection([[maybe_unused]] std::string_view lang = "") const {
        return g1_number_of_tenured_regions_at_mixed_collection_.GetValue();
    }

    void SetG1NumberOfTenuredRegionsAtMixedCollection(uint32_t value) {
        g1_number_of_tenured_regions_at_mixed_collection_.SetValue(value);
    }

    bool WasSetG1NumberOfTenuredRegionsAtMixedCollection([[maybe_unused]] std::string_view lang = "") const {
        return g1_number_of_tenured_regions_at_mixed_collection_.WasSet();
    }
    const std::string &GetG1TrackFreedObjects([[maybe_unused]] std::string_view lang = "") const {
        return g1_track_freed_objects_.GetValue();
    }

    void SetG1TrackFreedObjects(std::string value) {
        g1_track_freed_objects_.SetValue(std::move(value));
    }

    bool WasSetG1TrackFreedObjects([[maybe_unused]] std::string_view lang = "") const {
        return g1_track_freed_objects_.WasSet();
    }
    uint64_t GetGcMarkingStackNewTasksFrequency([[maybe_unused]] std::string_view lang = "") const {
        return gc_marking_stack_new_tasks_frequency_.GetValue();
    }

    void SetGcMarkingStackNewTasksFrequency(uint64_t value) {
        gc_marking_stack_new_tasks_frequency_.SetValue(value);
    }

    bool WasSetGcMarkingStackNewTasksFrequency([[maybe_unused]] std::string_view lang = "") const {
        return gc_marking_stack_new_tasks_frequency_.WasSet();
    }
    uint32_t GetGcRootMarkingStackMaxSize([[maybe_unused]] std::string_view lang = "") const {
        return gc_root_marking_stack_max_size_.GetValue();
    }

    void SetGcRootMarkingStackMaxSize(uint32_t value) {
        gc_root_marking_stack_max_size_.SetValue(value);
    }

    bool WasSetGcRootMarkingStackMaxSize([[maybe_unused]] std::string_view lang = "") const {
        return gc_root_marking_stack_max_size_.WasSet();
    }
    uint32_t GetGcWorkersMarkingStackMaxSize([[maybe_unused]] std::string_view lang = "") const {
        return gc_workers_marking_stack_max_size_.GetValue();
    }

    void SetGcWorkersMarkingStackMaxSize(uint32_t value) {
        gc_workers_marking_stack_max_size_.SetValue(value);
    }

    bool WasSetGcWorkersMarkingStackMaxSize([[maybe_unused]] std::string_view lang = "") const {
        return gc_workers_marking_stack_max_size_.WasSet();
    }
    bool IsGcParallelMarkingEnabled([[maybe_unused]] std::string_view lang = "") const {
        return gc_parallel_marking_enabled_.GetValue();
    }

    void SetGcParallelMarkingEnabled(bool value) {
        gc_parallel_marking_enabled_.SetValue(value);
    }

    bool WasSetGcParallelMarkingEnabled([[maybe_unused]] std::string_view lang = "") const {
        return gc_parallel_marking_enabled_.WasSet();
    }
    bool IsGcParallelCompactingEnabled([[maybe_unused]] std::string_view lang = "") const {
        return gc_parallel_compacting_enabled_.GetValue();
    }

    void SetGcParallelCompactingEnabled(bool value) {
        gc_parallel_compacting_enabled_.SetValue(value);
    }

    bool WasSetGcParallelCompactingEnabled([[maybe_unused]] std::string_view lang = "") const {
        return gc_parallel_compacting_enabled_.WasSet();
    }
    bool IsGcParallelRefUpdatingEnabled([[maybe_unused]] std::string_view lang = "") const {
        return gc_parallel_ref_updating_enabled_.GetValue();
    }

    void SetGcParallelRefUpdatingEnabled(bool value) {
        gc_parallel_ref_updating_enabled_.SetValue(value);
    }

    bool WasSetGcParallelRefUpdatingEnabled([[maybe_unused]] std::string_view lang = "") const {
        return gc_parallel_ref_updating_enabled_.WasSet();
    }
    uint64_t GetLongGcThresholdNs([[maybe_unused]] std::string_view lang = "") const {
        return long_gc_threshold_ns_.GetValue();
    }

    void SetLongGcThresholdNs(uint64_t value) {
        long_gc_threshold_ns_.SetValue(value);
    }

    bool WasSetLongGcThresholdNs([[maybe_unused]] std::string_view lang = "") const {
        return long_gc_threshold_ns_.WasSet();
    }
    bool IsG1SinglePassCompactionEnabled([[maybe_unused]] std::string_view lang = "") const {
        return g1_single_pass_compaction_enabled_.GetValue();
    }

    void SetG1SinglePassCompactionEnabled(bool value) {
        g1_single_pass_compaction_enabled_.SetValue(value);
    }

    bool WasSetG1SinglePassCompactionEnabled([[maybe_unused]] std::string_view lang = "") const {
        return g1_single_pass_compaction_enabled_.WasSet();
    }
    bool IsReferenceProcessorEnable([[maybe_unused]] std::string_view lang = "") const {
        return reference_processor_enable_.GetValue();
    }

    void SetReferenceProcessorEnable(bool value) {
        reference_processor_enable_.SetValue(value);
    }

    bool WasSetReferenceProcessorEnable([[maybe_unused]] std::string_view lang = "") const {
        return reference_processor_enable_.WasSet();
    }
    const std::string &GetLogLevel([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-level' is deprecated and should not be used\n";
        return log_level_.GetValue();
    }

    void SetLogLevel(std::string value) {
        std::cerr << "WARNING: Option 'log-level' is deprecated and should not be used\n";
        log_level_.SetValue(std::move(value));
    }

    bool WasSetLogLevel([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-level' is deprecated and should not be used\n";
        return log_level_.WasSet();
    }
    const std::string &GetLogStream([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-stream' is deprecated and should not be used\n";
        return log_stream_.GetValue();
    }

    void SetLogStream(std::string value) {
        std::cerr << "WARNING: Option 'log-stream' is deprecated and should not be used\n";
        log_stream_.SetValue(std::move(value));
    }

    bool WasSetLogStream([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-stream' is deprecated and should not be used\n";
        return log_stream_.WasSet();
    }
    const std::string &GetLogFile([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-file' is deprecated and should not be used\n";
        return log_file_.GetValue();
    }

    void SetLogFile(std::string value) {
        std::cerr << "WARNING: Option 'log-file' is deprecated and should not be used\n";
        log_file_.SetValue(std::move(value));
    }

    bool WasSetLogFile([[maybe_unused]] std::string_view lang = "") const {
        std::cerr << "WARNING: Option 'log-file' is deprecated and should not be used\n";
        return log_file_.WasSet();
    }
    bool IsGcEnableTracing([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsGcEnableTracing() ? ets_gc_enable_tracing_.GetValue() : gc_enable_tracing_.GetValue();
        }
        return gc_enable_tracing_.GetValue();
    }

    void SetGcEnableTracing(bool value) {
        gc_enable_tracing_.SetValue(value);
    }

    bool WasSetGcEnableTracing(std::string_view lang) const {
        if (lang == "ets") {
            return ets_gc_enable_tracing_.WasSet();
        }
        return gc_enable_tracing_.WasSet();
    }
    bool IsG1EnableConcurrentUpdateRemset([[maybe_unused]] std::string_view lang = "") const {
        return g1_enable_concurrent_update_remset_.GetValue();
    }

    void SetG1EnableConcurrentUpdateRemset(bool value) {
        g1_enable_concurrent_update_remset_.SetValue(value);
    }

    bool WasSetG1EnableConcurrentUpdateRemset([[maybe_unused]] std::string_view lang = "") const {
        return g1_enable_concurrent_update_remset_.WasSet();
    }
    uint32_t GetG1MinConcurrentCardsToProcess([[maybe_unused]] std::string_view lang = "") const {
        return g1_min_concurrent_cards_to_process_.GetValue();
    }

    void SetG1MinConcurrentCardsToProcess(uint32_t value) {
        g1_min_concurrent_cards_to_process_.SetValue(value);
    }

    bool WasSetG1MinConcurrentCardsToProcess([[maybe_unused]] std::string_view lang = "") const {
        return g1_min_concurrent_cards_to_process_.WasSet();
    }
    uint32_t GetG1HotCardsProcessingFrequency([[maybe_unused]] std::string_view lang = "") const {
        return g1_hot_cards_processing_frequency_.GetValue();
    }

    void SetG1HotCardsProcessingFrequency(uint32_t value) {
        g1_hot_cards_processing_frequency_.SetValue(value);
    }

    bool WasSetG1HotCardsProcessingFrequency([[maybe_unused]] std::string_view lang = "") const {
        return g1_hot_cards_processing_frequency_.WasSet();
    }
    uint32_t GetG1PromotionRegionAliveRate([[maybe_unused]] std::string_view lang = "") const {
        return g1_promotion_region_alive_rate_.GetValue();
    }

    void SetG1PromotionRegionAliveRate(uint32_t value) {
        g1_promotion_region_alive_rate_.SetValue(value);
    }

    bool WasSetG1PromotionRegionAliveRate([[maybe_unused]] std::string_view lang = "") const {
        return g1_promotion_region_alive_rate_.WasSet();
    }
    uint32_t GetG1FullGcRegionFragmentationRate([[maybe_unused]] std::string_view lang = "") const {
        return g1_full_gc_region_fragmentation_rate_.GetValue();
    }

    void SetG1FullGcRegionFragmentationRate(uint32_t value) {
        g1_full_gc_region_fragmentation_rate_.SetValue(value);
    }

    bool WasSetG1FullGcRegionFragmentationRate([[maybe_unused]] std::string_view lang = "") const {
        return g1_full_gc_region_fragmentation_rate_.WasSet();
    }
    uint32_t GetG1PauseTimeGoalMaxGcPause([[maybe_unused]] std::string_view lang = "") const {
        return g1_pause_time_goal_max_gc_pause_.GetValue();
    }

    void SetG1PauseTimeGoalMaxGcPause(uint32_t value) {
        g1_pause_time_goal_max_gc_pause_.SetValue(value);
    }

    bool WasSetG1PauseTimeGoalMaxGcPause([[maybe_unused]] std::string_view lang = "") const {
        return g1_pause_time_goal_max_gc_pause_.WasSet();
    }
    uint32_t GetG1PauseTimeGoalGcPauseInterval([[maybe_unused]] std::string_view lang = "") const {
        return g1_pause_time_goal_gc_pause_interval_.GetValue();
    }

    void SetG1PauseTimeGoalGcPauseInterval(uint32_t value) {
        g1_pause_time_goal_gc_pause_interval_.SetValue(value);
    }

    bool WasSetG1PauseTimeGoalGcPauseInterval([[maybe_unused]] std::string_view lang = "") const {
        return g1_pause_time_goal_gc_pause_interval_.WasSet();
    }
    bool IsG1PauseTimeGoal([[maybe_unused]] std::string_view lang = "") const {
        return g1_pause_time_goal_.GetValue();
    }

    void SetG1PauseTimeGoal(bool value) {
        g1_pause_time_goal_.SetValue(value);
    }

    bool WasSetG1PauseTimeGoal([[maybe_unused]] std::string_view lang = "") const {
        return g1_pause_time_goal_.WasSet();
    }
    bool IsDistributedProfiling([[maybe_unused]] std::string_view lang = "") const {
        return distributed_profiling_.GetValue();
    }

    void SetDistributedProfiling(bool value) {
        distributed_profiling_.SetValue(value);
    }

    bool WasSetDistributedProfiling([[maybe_unused]] std::string_view lang = "") const {
        return distributed_profiling_.WasSet();
    }
    const std::string &GetAotFile([[maybe_unused]] std::string_view lang = "") const {
        return aot_file_.GetValue();
    }

    void SetAotFile(std::string value) {
        aot_file_.SetValue(std::move(value));
    }

    bool WasSetAotFile([[maybe_unused]] std::string_view lang = "") const {
        return aot_file_.WasSet();
    }
    const arg_list_t &GetAotFiles([[maybe_unused]] std::string_view lang = "") const {
        return aot_files_.GetValue();
    }

    void SetAotFiles(arg_list_t value) {
        aot_files_.SetValue(std::move(value));
    }

    bool WasSetAotFiles([[maybe_unused]] std::string_view lang = "") const {
        return aot_files_.WasSet();
    }
    bool IsAotVerifyAbsPath([[maybe_unused]] std::string_view lang = "") const {
        return aot_verify_abs_path_.GetValue();
    }

    void SetAotVerifyAbsPath(bool value) {
        aot_verify_abs_path_.SetValue(value);
    }

    bool WasSetAotVerifyAbsPath([[maybe_unused]] std::string_view lang = "") const {
        return aot_verify_abs_path_.WasSet();
    }
    bool IsAdaptiveTlabSize([[maybe_unused]] std::string_view lang = "") const {
        return adaptive_tlab_size_.GetValue();
    }

    void SetAdaptiveTlabSize(bool value) {
        adaptive_tlab_size_.SetValue(value);
    }

    bool WasSetAdaptiveTlabSize([[maybe_unused]] std::string_view lang = "") const {
        return adaptive_tlab_size_.WasSet();
    }
    uint64_t GetInitTlabSize([[maybe_unused]] std::string_view lang = "") const {
        return init_tlab_size_.GetValue();
    }

    void SetInitTlabSize(uint64_t value) {
        init_tlab_size_.SetValue(value);
    }

    bool WasSetInitTlabSize([[maybe_unused]] std::string_view lang = "") const {
        return init_tlab_size_.WasSet();
    }
    uint64_t GetMaxTlabSize([[maybe_unused]] std::string_view lang = "") const {
        return max_tlab_size_.GetValue();
    }

    void SetMaxTlabSize(uint64_t value) {
        max_tlab_size_.SetValue(value);
    }

    bool WasSetMaxTlabSize([[maybe_unused]] std::string_view lang = "") const {
        return max_tlab_size_.WasSet();
    }
    bool IsUseTlabForAllocations([[maybe_unused]] std::string_view lang = "") const {
        return use_tlab_for_allocations_.GetValue();
    }

    void SetUseTlabForAllocations(bool value) {
        use_tlab_for_allocations_.SetValue(value);
    }

    bool WasSetUseTlabForAllocations([[maybe_unused]] std::string_view lang = "") const {
        return use_tlab_for_allocations_.WasSet();
    }
    uint64_t GetInitHeapSizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return init_heap_size_limit_.GetValue();
    }

    void SetInitHeapSizeLimit(uint64_t value) {
        init_heap_size_limit_.SetValue(value);
    }

    bool WasSetInitHeapSizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return init_heap_size_limit_.WasSet();
    }
    uint32_t GetHeapSizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return heap_size_limit_.GetValue();
    }

    void SetHeapSizeLimit(uint32_t value) {
        heap_size_limit_.SetValue(value);
    }

    bool WasSetHeapSizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return heap_size_limit_.WasSet();
    }
    uint64_t GetInternalMemorySizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return internal_memory_size_limit_.GetValue();
    }

    void SetInternalMemorySizeLimit(uint64_t value) {
        internal_memory_size_limit_.SetValue(value);
    }

    bool WasSetInternalMemorySizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return internal_memory_size_limit_.WasSet();
    }
    uint64_t GetFramesMemorySizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return frames_memory_size_limit_.GetValue();
    }

    void SetFramesMemorySizeLimit(uint64_t value) {
        frames_memory_size_limit_.SetValue(value);
    }

    bool WasSetFramesMemorySizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return frames_memory_size_limit_.WasSet();
    }
    uint32_t GetMinHeapFreePercentage([[maybe_unused]] std::string_view lang = "") const {
        return min_heap_free_percentage_.GetValue();
    }

    void SetMinHeapFreePercentage(uint32_t value) {
        min_heap_free_percentage_.SetValue(value);
    }

    bool WasSetMinHeapFreePercentage([[maybe_unused]] std::string_view lang = "") const {
        return min_heap_free_percentage_.WasSet();
    }
    uint32_t GetMaxHeapFreePercentage([[maybe_unused]] std::string_view lang = "") const {
        return max_heap_free_percentage_.GetValue();
    }

    void SetMaxHeapFreePercentage(uint32_t value) {
        max_heap_free_percentage_.SetValue(value);
    }

    bool WasSetMaxHeapFreePercentage([[maybe_unused]] std::string_view lang = "") const {
        return max_heap_free_percentage_.WasSet();
    }
    uint64_t GetCodeCacheSizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return code_cache_size_limit_.GetValue();
    }

    void SetCodeCacheSizeLimit(uint64_t value) {
        code_cache_size_limit_.SetValue(value);
    }

    bool WasSetCodeCacheSizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return code_cache_size_limit_.WasSet();
    }
    uint64_t GetCompilerMemorySizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_size_limit_.GetValue();
    }

    void SetCompilerMemorySizeLimit(uint64_t value) {
        compiler_memory_size_limit_.SetValue(value);
    }

    bool WasSetCompilerMemorySizeLimit([[maybe_unused]] std::string_view lang = "") const {
        return compiler_memory_size_limit_.WasSet();
    }
    bool IsPrintMemoryStatistics([[maybe_unused]] std::string_view lang = "") const {
        return print_memory_statistics_.GetValue();
    }

    void SetPrintMemoryStatistics(bool value) {
        print_memory_statistics_.SetValue(value);
    }

    bool WasSetPrintMemoryStatistics([[maybe_unused]] std::string_view lang = "") const {
        return print_memory_statistics_.WasSet();
    }
    bool IsPrintGcStatistics([[maybe_unused]] std::string_view lang = "") const {
        return print_gc_statistics_.GetValue();
    }

    void SetPrintGcStatistics(bool value) {
        print_gc_statistics_.SetValue(value);
    }

    bool WasSetPrintGcStatistics([[maybe_unused]] std::string_view lang = "") const {
        return print_gc_statistics_.WasSet();
    }
    bool IsNoAsyncJit([[maybe_unused]] std::string_view lang = "") const {
        return no_async_jit_.GetValue();
    }

    void SetNoAsyncJit(bool value) {
        no_async_jit_.SetValue(value);
    }

    bool WasSetNoAsyncJit([[maybe_unused]] std::string_view lang = "") const {
        return no_async_jit_.WasSet();
    }
    const std::string &GetCompilerQueueType([[maybe_unused]] std::string_view lang = "") const {
        return compiler_queue_type_.GetValue();
    }

    void SetCompilerQueueType(std::string value) {
        compiler_queue_type_.SetValue(std::move(value));
    }

    bool WasSetCompilerQueueType([[maybe_unused]] std::string_view lang = "") const {
        return compiler_queue_type_.WasSet();
    }
    uint32_t GetCompilerTaskLifeSpan([[maybe_unused]] std::string_view lang = "") const {
        return compiler_task_life_span_.GetValue();
    }

    void SetCompilerTaskLifeSpan(uint32_t value) {
        compiler_task_life_span_.SetValue(value);
    }

    bool WasSetCompilerTaskLifeSpan([[maybe_unused]] std::string_view lang = "") const {
        return compiler_task_life_span_.WasSet();
    }
    uint32_t GetCompilerQueueMaxLength([[maybe_unused]] std::string_view lang = "") const {
        return compiler_queue_max_length_.GetValue();
    }

    void SetCompilerQueueMaxLength(uint32_t value) {
        compiler_queue_max_length_.SetValue(value);
    }

    bool WasSetCompilerQueueMaxLength([[maybe_unused]] std::string_view lang = "") const {
        return compiler_queue_max_length_.WasSet();
    }
    uint32_t GetCompilerEpochDuration([[maybe_unused]] std::string_view lang = "") const {
        return compiler_epoch_duration_.GetValue();
    }

    void SetCompilerEpochDuration(uint32_t value) {
        compiler_epoch_duration_.SetValue(value);
    }

    bool WasSetCompilerEpochDuration([[maybe_unused]] std::string_view lang = "") const {
        return compiler_epoch_duration_.WasSet();
    }
    uint32_t GetCompilerDeathCounterValue([[maybe_unused]] std::string_view lang = "") const {
        return compiler_death_counter_value_.GetValue();
    }

    void SetCompilerDeathCounterValue(uint32_t value) {
        compiler_death_counter_value_.SetValue(value);
    }

    bool WasSetCompilerDeathCounterValue([[maybe_unused]] std::string_view lang = "") const {
        return compiler_death_counter_value_.WasSet();
    }
    bool IsLimitStandardAlloc([[maybe_unused]] std::string_view lang = "") const {
        return limit_standard_alloc_.GetValue();
    }

    void SetLimitStandardAlloc(bool value) {
        limit_standard_alloc_.SetValue(value);
    }

    bool WasSetLimitStandardAlloc([[maybe_unused]] std::string_view lang = "") const {
        return limit_standard_alloc_.WasSet();
    }
    const std::string &GetInternalAllocatorType([[maybe_unused]] std::string_view lang = "") const {
        return internal_allocator_type_.GetValue();
    }

    void SetInternalAllocatorType(std::string value) {
        internal_allocator_type_.SetValue(std::move(value));
    }

    bool WasSetInternalAllocatorType([[maybe_unused]] std::string_view lang = "") const {
        return internal_allocator_type_.WasSet();
    }
    uint32_t GetFinalizerTimeoutMs([[maybe_unused]] std::string_view lang = "") const {
        return finalizer_timeout_ms_.GetValue();
    }

    void SetFinalizerTimeoutMs(uint32_t value) {
        finalizer_timeout_ms_.SetValue(value);
    }

    bool WasSetFinalizerTimeoutMs([[maybe_unused]] std::string_view lang = "") const {
        return finalizer_timeout_ms_.WasSet();
    }
    const arg_list_t &GetProperties([[maybe_unused]] std::string_view lang = "") const {
        return properties_.GetValue();
    }

    void SetProperties(arg_list_t value) {
        properties_.SetValue(std::move(value));
    }

    bool WasSetProperties([[maybe_unused]] std::string_view lang = "") const {
        return properties_.WasSet();
    }
    const std::string &GetEventsOutput([[maybe_unused]] std::string_view lang = "") const {
        return events_output_.GetValue();
    }

    void SetEventsOutput(std::string value) {
        events_output_.SetValue(std::move(value));
    }

    bool WasSetEventsOutput([[maybe_unused]] std::string_view lang = "") const {
        return events_output_.WasSet();
    }
    const std::string &GetEventsFile([[maybe_unused]] std::string_view lang = "") const {
        return events_file_.GetValue();
    }

    void SetEventsFile(std::string value) {
        events_file_.SetValue(std::move(value));
    }

    bool WasSetEventsFile([[maybe_unused]] std::string_view lang = "") const {
        return events_file_.WasSet();
    }
    bool IsMemAllocDumpExec([[maybe_unused]] std::string_view lang = "") const {
        return mem_alloc_dump_exec_.GetValue();
    }

    void SetMemAllocDumpExec(bool value) {
        mem_alloc_dump_exec_.SetValue(value);
    }

    bool WasSetMemAllocDumpExec([[maybe_unused]] std::string_view lang = "") const {
        return mem_alloc_dump_exec_.WasSet();
    }
    const std::string &GetMemAllocDumpFile([[maybe_unused]] std::string_view lang = "") const {
        return mem_alloc_dump_file_.GetValue();
    }

    void SetMemAllocDumpFile(std::string value) {
        mem_alloc_dump_file_.SetValue(std::move(value));
    }

    bool WasSetMemAllocDumpFile([[maybe_unused]] std::string_view lang = "") const {
        return mem_alloc_dump_file_.WasSet();
    }
    bool IsStartupTime([[maybe_unused]] std::string_view lang = "") const {
        return startup_time_.GetValue();
    }

    void SetStartupTime(bool value) {
        startup_time_.SetValue(value);
    }

    bool WasSetStartupTime([[maybe_unused]] std::string_view lang = "") const {
        return startup_time_.WasSet();
    }
    uint32_t GetMaxFree([[maybe_unused]] std::string_view lang = "") const {
        return max_free_.GetValue();
    }

    void SetMaxFree(uint32_t value) {
        max_free_.SetValue(value);
    }

    bool WasSetMaxFree([[maybe_unused]] std::string_view lang = "") const {
        return max_free_.WasSet();
    }
    const std::string &GetNativeGcTriggerType([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsNativeGcTriggerType() ? ets_native_gc_trigger_type_.GetValue() : native_gc_trigger_type_.GetValue();
        }
        return native_gc_trigger_type_.GetValue();
    }

    void SetNativeGcTriggerType(std::string value) {
        native_gc_trigger_type_.SetValue(std::move(value));
    }

    bool WasSetNativeGcTriggerType(std::string_view lang) const {
        if (lang == "ets") {
            return ets_native_gc_trigger_type_.WasSet();
        }
        return native_gc_trigger_type_.WasSet();
    }
    bool IsProfilerEnabled([[maybe_unused]] std::string_view lang = "") const {
        return profiler_enabled_.GetValue();
    }

    void SetProfilerEnabled(bool value) {
        profiler_enabled_.SetValue(value);
    }

    bool WasSetProfilerEnabled([[maybe_unused]] std::string_view lang = "") const {
        return profiler_enabled_.WasSet();
    }
    uint32_t GetProfilesaverSleepingTimeMs([[maybe_unused]] std::string_view lang = "") const {
        return profilesaver_sleeping_time_ms_.GetValue();
    }

    void SetProfilesaverSleepingTimeMs(uint32_t value) {
        profilesaver_sleeping_time_ms_.SetValue(value);
    }

    bool WasSetProfilesaverSleepingTimeMs([[maybe_unused]] std::string_view lang = "") const {
        return profilesaver_sleeping_time_ms_.WasSet();
    }
    uint64_t GetProfilesaverDeltaNumberThreshold([[maybe_unused]] std::string_view lang = "") const {
        return profilesaver_delta_number_threshold_.GetValue();
    }

    void SetProfilesaverDeltaNumberThreshold(uint64_t value) {
        profilesaver_delta_number_threshold_.SetValue(value);
    }

    bool WasSetProfilesaverDeltaNumberThreshold([[maybe_unused]] std::string_view lang = "") const {
        return profilesaver_delta_number_threshold_.WasSet();
    }
    bool IsProfilesaverEnabled([[maybe_unused]] std::string_view lang = "") const {
        return profilesaver_enabled_.GetValue();
    }

    void SetProfilesaverEnabled(bool value) {
        profilesaver_enabled_.SetValue(value);
    }

    bool WasSetProfilesaverEnabled([[maybe_unused]] std::string_view lang = "") const {
        return profilesaver_enabled_.WasSet();
    }
    bool IsIncrementalProfilesaverEnabled([[maybe_unused]] std::string_view lang = "") const {
        return incremental_profilesaver_enabled_.GetValue();
    }

    void SetIncrementalProfilesaverEnabled(bool value) {
        incremental_profilesaver_enabled_.SetValue(value);
    }

    bool WasSetIncrementalProfilesaverEnabled([[maybe_unused]] std::string_view lang = "") const {
        return incremental_profilesaver_enabled_.WasSet();
    }
    bool IsStartAsZygote([[maybe_unused]] std::string_view lang = "") const {
        return start_as_zygote_.GetValue();
    }

    void SetStartAsZygote(bool value) {
        start_as_zygote_.SetValue(value);
    }

    bool WasSetStartAsZygote([[maybe_unused]] std::string_view lang = "") const {
        return start_as_zygote_.WasSet();
    }
    const std::string &GetVerificationMode([[maybe_unused]] std::string_view lang = "") const {
        return verification_mode_.GetValue();
    }

    void SetVerificationMode(std::string value) {
        verification_mode_.SetValue(std::move(value));
    }

    bool WasSetVerificationMode([[maybe_unused]] std::string_view lang = "") const {
        return verification_mode_.WasSet();
    }
    bool IsVerificationUpdateCache([[maybe_unused]] std::string_view lang = "") const {
        return verification_update_cache_.GetValue();
    }

    void SetVerificationUpdateCache(bool value) {
        verification_update_cache_.SetValue(value);
    }

    bool WasSetVerificationUpdateCache([[maybe_unused]] std::string_view lang = "") const {
        return verification_update_cache_.WasSet();
    }
    uint32_t GetVerificationThreads([[maybe_unused]] std::string_view lang = "") const {
        return verification_threads_.GetValue();
    }

    void SetVerificationThreads(uint32_t value) {
        verification_threads_.SetValue(value);
    }

    bool WasSetVerificationThreads([[maybe_unused]] std::string_view lang = "") const {
        return verification_threads_.WasSet();
    }
    const std::string &GetVerificationConfigFile([[maybe_unused]] std::string_view lang = "") const {
        return verification_config_file_.GetValue();
    }

    void SetVerificationConfigFile(std::string value) {
        verification_config_file_.SetValue(std::move(value));
    }

    bool WasSetVerificationConfigFile([[maybe_unused]] std::string_view lang = "") const {
        return verification_config_file_.WasSet();
    }
    const std::string &GetVerificationCacheFile([[maybe_unused]] std::string_view lang = "") const {
        return verification_cache_file_.GetValue();
    }

    void SetVerificationCacheFile(std::string value) {
        verification_cache_file_.SetValue(std::move(value));
    }

    bool WasSetVerificationCacheFile([[maybe_unused]] std::string_view lang = "") const {
        return verification_cache_file_.WasSet();
    }
    bool IsEnableFastHeapVerifier([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsEnableFastHeapVerifier() ? ets_enable_fast_heap_verifier_.GetValue() : enable_fast_heap_verifier_.GetValue();
        }
        return enable_fast_heap_verifier_.GetValue();
    }

    void SetEnableFastHeapVerifier(bool value) {
        enable_fast_heap_verifier_.SetValue(value);
    }

    bool WasSetEnableFastHeapVerifier(std::string_view lang) const {
        if (lang == "ets") {
            return ets_enable_fast_heap_verifier_.WasSet();
        }
        return enable_fast_heap_verifier_.WasSet();
    }
    const arg_list_t &GetHeapVerifier([[maybe_unused]] std::string_view lang = "") const {
        return heap_verifier_.GetValue();
    }

    void SetHeapVerifier(arg_list_t value) {
        heap_verifier_.SetValue(std::move(value));
    }

    bool WasSetHeapVerifier([[maybe_unused]] std::string_view lang = "") const {
        return heap_verifier_.WasSet();
    }
    uint32_t GetMaxGlobalRefSize([[maybe_unused]] std::string_view lang = "") const {
        return max_global_ref_size_.GetValue();
    }

    void SetMaxGlobalRefSize(uint32_t value) {
        max_global_ref_size_.SetValue(value);
    }

    bool WasSetMaxGlobalRefSize([[maybe_unused]] std::string_view lang = "") const {
        return max_global_ref_size_.WasSet();
    }
    bool IsGlobalReferenceSizeCheckEnabled([[maybe_unused]] std::string_view lang = "") const {
        return global_reference_size_check_enabled_.GetValue();
    }

    void SetGlobalReferenceSizeCheckEnabled(bool value) {
        global_reference_size_check_enabled_.SetValue(value);
    }

    bool WasSetGlobalReferenceSizeCheckEnabled([[maybe_unused]] std::string_view lang = "") const {
        return global_reference_size_check_enabled_.WasSet();
    }
    bool IsConcurrentGcEnabled([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsConcurrentGcEnabled() ? ets_concurrent_gc_enabled_.GetValue() : concurrent_gc_enabled_.GetValue();
        }
        return concurrent_gc_enabled_.GetValue();
    }

    void SetConcurrentGcEnabled(bool value) {
        concurrent_gc_enabled_.SetValue(value);
    }

    bool WasSetConcurrentGcEnabled(std::string_view lang) const {
        if (lang == "ets") {
            return ets_concurrent_gc_enabled_.WasSet();
        }
        return concurrent_gc_enabled_.WasSet();
    }
    bool IsSnapshotSerializeEnabled([[maybe_unused]] std::string_view lang = "") const {
        return snapshot_serialize_enabled_.GetValue();
    }

    void SetSnapshotSerializeEnabled(bool value) {
        snapshot_serialize_enabled_.SetValue(value);
    }

    bool WasSetSnapshotSerializeEnabled([[maybe_unused]] std::string_view lang = "") const {
        return snapshot_serialize_enabled_.WasSet();
    }
    bool IsSnapshotDeserializeEnabled([[maybe_unused]] std::string_view lang = "") const {
        return snapshot_deserialize_enabled_.GetValue();
    }

    void SetSnapshotDeserializeEnabled(bool value) {
        snapshot_deserialize_enabled_.SetValue(value);
    }

    bool WasSetSnapshotDeserializeEnabled([[maybe_unused]] std::string_view lang = "") const {
        return snapshot_deserialize_enabled_.WasSet();
    }
    const std::string &GetSnapshotFile([[maybe_unused]] std::string_view lang = "") const {
        return snapshot_file_.GetValue();
    }

    void SetSnapshotFile(std::string value) {
        snapshot_file_.SetValue(std::move(value));
    }

    bool WasSetSnapshotFile([[maybe_unused]] std::string_view lang = "") const {
        return snapshot_file_.WasSet();
    }
    const std::string &GetFrameworkAbcFile([[maybe_unused]] std::string_view lang = "") const {
        return framework_abc_file_.GetValue();
    }

    void SetFrameworkAbcFile(std::string value) {
        framework_abc_file_.SetValue(std::move(value));
    }

    bool WasSetFrameworkAbcFile([[maybe_unused]] std::string_view lang = "") const {
        return framework_abc_file_.WasSet();
    }
    const std::string &GetBootAnLocation([[maybe_unused]] std::string_view lang = "") const {
        return boot_an_location_.GetValue();
    }

    void SetBootAnLocation(std::string value) {
        boot_an_location_.SetValue(std::move(value));
    }

    bool WasSetBootAnLocation([[maybe_unused]] std::string_view lang = "") const {
        return boot_an_location_.WasSet();
    }
    bool IsEnableAnForce([[maybe_unused]] std::string_view lang = "") const {
        return enable_an_force_.GetValue();
    }

    void SetEnableAnForce(bool value) {
        enable_an_force_.SetValue(value);
    }

    bool WasSetEnableAnForce([[maybe_unused]] std::string_view lang = "") const {
        return enable_an_force_.WasSet();
    }
    bool IsEnableAn([[maybe_unused]] std::string_view lang = "") const {
        return enable_an_.GetValue();
    }

    void SetEnableAn(bool value) {
        enable_an_.SetValue(value);
    }

    bool WasSetEnableAn([[maybe_unused]] std::string_view lang = "") const {
        return enable_an_.WasSet();
    }
    bool IsVerifyCallStack([[maybe_unused]] std::string_view lang = "") const {
        return verify_call_stack_.GetValue();
    }

    void SetVerifyCallStack(bool value) {
        verify_call_stack_.SetValue(value);
    }

    bool WasSetVerifyCallStack([[maybe_unused]] std::string_view lang = "") const {
        return verify_call_stack_.WasSet();
    }
    bool IsSafepointBacktrace([[maybe_unused]] std::string_view lang = "") const {
        return safepoint_backtrace_.GetValue();
    }

    void SetSafepointBacktrace(bool value) {
        safepoint_backtrace_.SetValue(value);
    }

    bool WasSetSafepointBacktrace([[maybe_unused]] std::string_view lang = "") const {
        return safepoint_backtrace_.WasSet();
    }
    uint64_t GetAotStringGcRootsLimit([[maybe_unused]] std::string_view lang = "") const {
        return aot_string_gc_roots_limit_.GetValue();
    }

    void SetAotStringGcRootsLimit(uint64_t value) {
        aot_string_gc_roots_limit_.SetValue(value);
    }

    bool WasSetAotStringGcRootsLimit([[maybe_unused]] std::string_view lang = "") const {
        return aot_string_gc_roots_limit_.WasSet();
    }
    uint32_t GetResolveStringAotThreshold([[maybe_unused]] std::string_view lang = "") const {
        return resolve_string_aot_threshold_.GetValue();
    }

    void SetResolveStringAotThreshold(uint32_t value) {
        resolve_string_aot_threshold_.SetValue(value);
    }

    bool WasSetResolveStringAotThreshold([[maybe_unused]] std::string_view lang = "") const {
        return resolve_string_aot_threshold_.WasSet();
    }
    const std::string &GetIcuDataPath([[maybe_unused]] std::string_view lang = "") const {
        return icu_data_path_.GetValue();
    }

    void SetIcuDataPath(std::string value) {
        icu_data_path_.SetValue(std::move(value));
    }

    bool WasSetIcuDataPath([[maybe_unused]] std::string_view lang = "") const {
        return icu_data_path_.WasSet();
    }
    bool IsArkAot([[maybe_unused]] std::string_view lang = "") const {
        return ark_aot_.GetValue();
    }

    void SetArkAot(bool value) {
        ark_aot_.SetValue(value);
    }

    bool WasSetArkAot([[maybe_unused]] std::string_view lang = "") const {
        return ark_aot_.WasSet();
    }
    const arg_list_t &GetIntrinsicsBlacklist([[maybe_unused]] std::string_view lang = "") const {
        return intrinsics_blacklist_.GetValue();
    }

    void SetIntrinsicsBlacklist(arg_list_t value) {
        intrinsics_blacklist_.SetValue(std::move(value));
    }

    bool WasSetIntrinsicsBlacklist([[maybe_unused]] std::string_view lang = "") const {
        return intrinsics_blacklist_.WasSet();
    }
    bool IsVerifyEntrypoints([[maybe_unused]] std::string_view lang = "") const {
        return verify_entrypoints_.GetValue();
    }

    void SetVerifyEntrypoints(bool value) {
        verify_entrypoints_.SetValue(value);
    }

    bool WasSetVerifyEntrypoints([[maybe_unused]] std::string_view lang = "") const {
        return verify_entrypoints_.WasSet();
    }
    uint32_t GetIgnoreDaemonMemoryLeaksThreshold([[maybe_unused]] std::string_view lang = "") const {
        return ignore_daemon_memory_leaks_threshold_.GetValue();
    }

    void SetIgnoreDaemonMemoryLeaksThreshold(uint32_t value) {
        ignore_daemon_memory_leaks_threshold_.SetValue(value);
    }

    bool WasSetIgnoreDaemonMemoryLeaksThreshold([[maybe_unused]] std::string_view lang = "") const {
        return ignore_daemon_memory_leaks_threshold_.WasSet();
    }
    const std::string &GetInterpreterType([[maybe_unused]] std::string_view lang = "") const {
        return interpreter_type_.GetValue();
    }

    void SetInterpreterType(std::string value) {
        interpreter_type_.SetValue(std::move(value));
    }

    bool WasSetInterpreterType([[maybe_unused]] std::string_view lang = "") const {
        return interpreter_type_.WasSet();
    }
    const std::string &GetAbcLayoutProfileLocation([[maybe_unused]] std::string_view lang = "") const {
        return abc_layout_profile_location_.GetValue();
    }

    void SetAbcLayoutProfileLocation(std::string value) {
        abc_layout_profile_location_.SetValue(std::move(value));
    }

    bool WasSetAbcLayoutProfileLocation([[maybe_unused]] std::string_view lang = "") const {
        return abc_layout_profile_location_.WasSet();
    }
    uint32_t GetIntrusiveTest([[maybe_unused]] std::string_view lang = "") const {
        return intrusive_test_.GetValue();
    }

    void SetIntrusiveTest(uint32_t value) {
        intrusive_test_.SetValue(value);
    }

    bool WasSetIntrusiveTest([[maybe_unused]] std::string_view lang = "") const {
        return intrusive_test_.WasSet();
    }
    const std::string &GetProfileOutput([[maybe_unused]] std::string_view lang = "") const {
        return profile_output_.GetValue();
    }

    void SetProfileOutput(std::string value) {
        profile_output_.SetValue(std::move(value));
    }

    bool WasSetProfileOutput([[maybe_unused]] std::string_view lang = "") const {
        return profile_output_.WasSet();
    }
    uint32_t GetCallProfilingTableSize([[maybe_unused]] std::string_view lang = "") const {
        return call_profiling_table_size_.GetValue();
    }

    void SetCallProfilingTableSize(uint32_t value) {
        call_profiling_table_size_.SetValue(value);
    }

    bool WasSetCallProfilingTableSize([[maybe_unused]] std::string_view lang = "") const {
        return call_profiling_table_size_.WasSet();
    }
    uint32_t GetCoroutineStackSizePages([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_stack_size_pages_.GetValue();
    }

    void SetCoroutineStackSizePages(uint32_t value) {
        coroutine_stack_size_pages_.SetValue(value);
    }

    bool WasSetCoroutineStackSizePages([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_stack_size_pages_.WasSet();
    }
    uint64_t GetCoroutinesStackMemLimit([[maybe_unused]] std::string_view lang = "") const {
        return coroutines_stack_mem_limit_.GetValue();
    }

    void SetCoroutinesStackMemLimit(uint64_t value) {
        coroutines_stack_mem_limit_.SetValue(value);
    }

    bool WasSetCoroutinesStackMemLimit([[maybe_unused]] std::string_view lang = "") const {
        return coroutines_stack_mem_limit_.WasSet();
    }
    uint64_t GetCoroutinesUserLimit([[maybe_unused]] std::string_view lang = "") const {
        return coroutines_user_limit_.GetValue();
    }

    void SetCoroutinesUserLimit(uint64_t value) {
        coroutines_user_limit_.SetValue(value);
    }

    bool WasSetCoroutinesUserLimit([[maybe_unused]] std::string_view lang = "") const {
        return coroutines_user_limit_.WasSet();
    }
    bool IsUseCoroutinePool([[maybe_unused]] std::string_view lang = "") const {
        return use_coroutine_pool_.GetValue();
    }

    void SetUseCoroutinePool(bool value) {
        use_coroutine_pool_.SetValue(value);
    }

    bool WasSetUseCoroutinePool([[maybe_unused]] std::string_view lang = "") const {
        return use_coroutine_pool_.WasSet();
    }
    const std::string &GetWorkersType([[maybe_unused]] std::string_view lang = "") const {
        return workers_type_.GetValue();
    }

    void SetWorkersType(std::string value) {
        workers_type_.SetValue(std::move(value));
    }

    bool WasSetWorkersType([[maybe_unused]] std::string_view lang = "") const {
        return workers_type_.WasSet();
    }
    uint32_t GetTaskmanagerWorkersCount([[maybe_unused]] std::string_view lang = "") const {
        return taskmanager_workers_count_.GetValue();
    }

    void SetTaskmanagerWorkersCount(uint32_t value) {
        taskmanager_workers_count_.SetValue(value);
    }

    bool WasSetTaskmanagerWorkersCount([[maybe_unused]] std::string_view lang = "") const {
        return taskmanager_workers_count_.WasSet();
    }
    const std::string &GetTaskStatsType([[maybe_unused]] std::string_view lang = "") const {
        return task_stats_type_.GetValue();
    }

    void SetTaskStatsType(std::string value) {
        task_stats_type_.SetValue(std::move(value));
    }

    bool WasSetTaskStatsType([[maybe_unused]] std::string_view lang = "") const {
        return task_stats_type_.WasSet();
    }
    bool IsLoadInBoot([[maybe_unused]] std::string_view lang = "") const {
        return load_in_boot_.GetValue();
    }

    void SetLoadInBoot(bool value) {
        load_in_boot_.SetValue(value);
    }

    bool WasSetLoadInBoot([[maybe_unused]] std::string_view lang = "") const {
        return load_in_boot_.WasSet();
    }
    bool IsUseStringCaches([[maybe_unused]] std::string_view lang = "") const {
        return use_string_caches_.GetValue();
    }

    void SetUseStringCaches(bool value) {
        use_string_caches_.SetValue(value);
    }

    bool WasSetUseStringCaches([[maybe_unused]] std::string_view lang = "") const {
        return use_string_caches_.WasSet();
    }
    bool IsUseAllStrings([[maybe_unused]] std::string_view lang = "") const {
        return use_all_strings_.GetValue();
    }

    void SetUseAllStrings(bool value) {
        use_all_strings_.SetValue(value);
    }

    bool WasSetUseAllStrings([[maybe_unused]] std::string_view lang = "") const {
        return use_all_strings_.WasSet();
    }
    bool IsCodeCoverageEnabled([[maybe_unused]] std::string_view lang = "") const {
        return code_coverage_enabled_.GetValue();
    }

    void SetCodeCoverageEnabled(bool value) {
        code_coverage_enabled_.SetValue(value);
    }

    bool WasSetCodeCoverageEnabled([[maybe_unused]] std::string_view lang = "") const {
        return code_coverage_enabled_.WasSet();
    }
    const std::string &GetCodeCoverageOutput([[maybe_unused]] std::string_view lang = "") const {
        return code_coverage_output_.GetValue();
    }

    void SetCodeCoverageOutput(std::string value) {
        code_coverage_output_.SetValue(std::move(value));
    }

    bool WasSetCodeCoverageOutput([[maybe_unused]] std::string_view lang = "") const {
        return code_coverage_output_.WasSet();
    }
    bool IsUseBootClassFilter([[maybe_unused]] std::string_view lang = "") const {
        return use_boot_class_filter_.GetValue();
    }

    void SetUseBootClassFilter(bool value) {
        use_boot_class_filter_.SetValue(value);
    }

    bool WasSetUseBootClassFilter([[maybe_unused]] std::string_view lang = "") const {
        return use_boot_class_filter_.WasSet();
    }
    bool IsEnableClassLinkerTrace([[maybe_unused]] std::string_view lang = "") const {
        return enable_class_linker_trace_.GetValue();
    }

    void SetEnableClassLinkerTrace(bool value) {
        enable_class_linker_trace_.SetValue(value);
    }

    bool WasSetEnableClassLinkerTrace([[maybe_unused]] std::string_view lang = "") const {
        return enable_class_linker_trace_.WasSet();
    }
    uint32_t GetXgcMinTriggerThreshold([[maybe_unused]] std::string_view lang = "") const {
        return xgc_min_trigger_threshold_.GetValue();
    }

    void SetXgcMinTriggerThreshold(uint32_t value) {
        xgc_min_trigger_threshold_.SetValue(value);
    }

    bool WasSetXgcMinTriggerThreshold([[maybe_unused]] std::string_view lang = "") const {
        return xgc_min_trigger_threshold_.WasSet();
    }
    uint32_t GetXgcTriggerPercentThreshold([[maybe_unused]] std::string_view lang = "") const {
        return xgc_trigger_percent_threshold_.GetValue();
    }

    void SetXgcTriggerPercentThreshold(uint32_t value) {
        xgc_trigger_percent_threshold_.SetValue(value);
    }

    bool WasSetXgcTriggerPercentThreshold([[maybe_unused]] std::string_view lang = "") const {
        return xgc_trigger_percent_threshold_.WasSet();
    }
    const std::string &GetXgcTriggerType([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsXgcTriggerType() ? ets_xgc_trigger_type_.GetValue() : xgc_trigger_type_.GetValue();
        }
        return xgc_trigger_type_.GetValue();
    }

    void SetXgcTriggerType(std::string value) {
        xgc_trigger_type_.SetValue(std::move(value));
    }

    bool WasSetXgcTriggerType(std::string_view lang) const {
        if (lang == "ets") {
            return ets_xgc_trigger_type_.WasSet();
        }
        return xgc_trigger_type_.WasSet();
    }
    bool IsEnableXgcVerifier([[maybe_unused]] std::string_view lang = "") const {
        return enable_xgc_verifier_.GetValue();
    }

    void SetEnableXgcVerifier(bool value) {
        enable_xgc_verifier_.SetValue(value);
    }

    bool WasSetEnableXgcVerifier([[maybe_unused]] std::string_view lang = "") const {
        return enable_xgc_verifier_.WasSet();
    }
    bool IsTaskpoolSupportInterop([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsTaskpoolSupportInterop() ? ets_taskpool_support_interop_.GetValue() : taskpool_support_interop_.GetValue();
        }
        return taskpool_support_interop_.GetValue();
    }

    void SetTaskpoolSupportInterop(bool value) {
        taskpool_support_interop_.SetValue(value);
    }

    bool WasSetTaskpoolSupportInterop(std::string_view lang) const {
        if (lang == "ets") {
            return ets_taskpool_support_interop_.WasSet();
        }
        return taskpool_support_interop_.WasSet();
    }
    bool IsFailOnHeapVerification([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsFailOnHeapVerification() ? ets_fail_on_heap_verification_.GetValue() : fail_on_heap_verification_.GetValue();
        }
        return fail_on_heap_verification_.GetValue();
    }

    void SetFailOnHeapVerification(bool value) {
        fail_on_heap_verification_.SetValue(value);
    }

    bool WasSetFailOnHeapVerification(std::string_view lang) const {
        if (lang == "ets") {
            return ets_fail_on_heap_verification_.WasSet();
        }
        return fail_on_heap_verification_.WasSet();
    }
    bool IsPreGcHeapVerifyEnabled([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsPreGcHeapVerifyEnabled() ? ets_pre_gc_heap_verify_enabled_.GetValue() : pre_gc_heap_verify_enabled_.GetValue();
        }
        return pre_gc_heap_verify_enabled_.GetValue();
    }

    void SetPreGcHeapVerifyEnabled(bool value) {
        pre_gc_heap_verify_enabled_.SetValue(value);
    }

    bool WasSetPreGcHeapVerifyEnabled(std::string_view lang) const {
        if (lang == "ets") {
            return ets_pre_gc_heap_verify_enabled_.WasSet();
        }
        return pre_gc_heap_verify_enabled_.WasSet();
    }
    bool IsIntoGcHeapVerifyEnabled([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsIntoGcHeapVerifyEnabled() ? ets_into_gc_heap_verify_enabled_.GetValue() : into_gc_heap_verify_enabled_.GetValue();
        }
        return into_gc_heap_verify_enabled_.GetValue();
    }

    void SetIntoGcHeapVerifyEnabled(bool value) {
        into_gc_heap_verify_enabled_.SetValue(value);
    }

    bool WasSetIntoGcHeapVerifyEnabled(std::string_view lang) const {
        if (lang == "ets") {
            return ets_into_gc_heap_verify_enabled_.WasSet();
        }
        return into_gc_heap_verify_enabled_.WasSet();
    }
    bool IsPostGcHeapVerifyEnabled([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsPostGcHeapVerifyEnabled() ? ets_post_gc_heap_verify_enabled_.GetValue() : post_gc_heap_verify_enabled_.GetValue();
        }
        return post_gc_heap_verify_enabled_.GetValue();
    }

    void SetPostGcHeapVerifyEnabled(bool value) {
        post_gc_heap_verify_enabled_.SetValue(value);
    }

    bool WasSetPostGcHeapVerifyEnabled(std::string_view lang) const {
        if (lang == "ets") {
            return ets_post_gc_heap_verify_enabled_.WasSet();
        }
        return post_gc_heap_verify_enabled_.WasSet();
    }
    bool IsEnableParalledYoungGc([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsEnableParalledYoungGc() ? ets_enable_paralled_young_gc_.GetValue() : enable_paralled_young_gc_.GetValue();
        }
        return enable_paralled_young_gc_.GetValue();
    }

    void SetEnableParalledYoungGc(bool value) {
        enable_paralled_young_gc_.SetValue(value);
    }

    bool WasSetEnableParalledYoungGc(std::string_view lang) const {
        if (lang == "ets") {
            return ets_enable_paralled_young_gc_.WasSet();
        }
        return enable_paralled_young_gc_.WasSet();
    }
    const std::string &GetCoroutineImpl([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsCoroutineImpl() ? ets_coroutine_impl_.GetValue() : coroutine_impl_.GetValue();
        }
        return coroutine_impl_.GetValue();
    }

    void SetCoroutineImpl(std::string value) {
        coroutine_impl_.SetValue(std::move(value));
    }

    bool WasSetCoroutineImpl(std::string_view lang) const {
        if (lang == "ets") {
            return ets_coroutine_impl_.WasSet();
        }
        return coroutine_impl_.WasSet();
    }
    uint32_t GetCoroutineWorkersCount([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsCoroutineWorkersCount() ? ets_coroutine_workers_count_.GetValue() : coroutine_workers_count_.GetValue();
        }
        return coroutine_workers_count_.GetValue();
    }

    void SetCoroutineWorkersCount(uint32_t value) {
        coroutine_workers_count_.SetValue(value);
    }

    bool WasSetCoroutineWorkersCount(std::string_view lang) const {
        if (lang == "ets") {
            return ets_coroutine_workers_count_.WasSet();
        }
        return coroutine_workers_count_.WasSet();
    }
    uint32_t GetCoroutineEWorkersLimit([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsCoroutineEWorkersLimit() ? ets_coroutine_e_workers_limit_.GetValue() : coroutine_e_workers_limit_.GetValue();
        }
        return coroutine_e_workers_limit_.GetValue();
    }

    void SetCoroutineEWorkersLimit(uint32_t value) {
        coroutine_e_workers_limit_.SetValue(value);
    }

    bool WasSetCoroutineEWorkersLimit(std::string_view lang) const {
        if (lang == "ets") {
            return ets_coroutine_e_workers_limit_.WasSet();
        }
        return coroutine_e_workers_limit_.WasSet();
    }
    bool IsCoroutineEnableFeaturesAniDrainQueue([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_ani_drain_queue_.GetValue();
    }

    void SetCoroutineEnableFeaturesAniDrainQueue(bool value) {
        coroutine_enable_features_ani_drain_queue_.SetValue(value);
    }

    bool WasSetCoroutineEnableFeaturesAniDrainQueue([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_ani_drain_queue_.WasSet();
    }
    bool IsCoroutineEnableFeaturesMigration([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_migration_.GetValue();
    }

    void SetCoroutineEnableFeaturesMigration(bool value) {
        coroutine_enable_features_migration_.SetValue(value);
    }

    bool WasSetCoroutineEnableFeaturesMigration([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_migration_.WasSet();
    }
    bool IsCoroutineEnableFeaturesMigrateAwakened([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_migrate_awakened_.GetValue();
    }

    void SetCoroutineEnableFeaturesMigrateAwakened(bool value) {
        coroutine_enable_features_migrate_awakened_.SetValue(value);
    }

    bool WasSetCoroutineEnableFeaturesMigrateAwakened([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_migrate_awakened_.WasSet();
    }
    bool IsCoroutineEnableFeaturesEnableExternalTimer([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_enable_external_timer_.GetValue();
    }

    void SetCoroutineEnableFeaturesEnableExternalTimer(bool value) {
        coroutine_enable_features_enable_external_timer_.SetValue(value);
    }

    bool WasSetCoroutineEnableFeaturesEnableExternalTimer([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_enable_external_timer_.WasSet();
    }
    bool IsCoroutineEnableFeatures([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_.GetValue();
    }

    void SetCoroutineEnableFeatures(bool value) {
        coroutine_enable_features_.SetValue(value);
    }

    bool WasSetCoroutineEnableFeatures([[maybe_unused]] std::string_view lang = "") const {
        return coroutine_enable_features_.WasSet();
    }
    bool IsCoroutineDumpStats([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsCoroutineDumpStats() ? ets_coroutine_dump_stats_.GetValue() : coroutine_dump_stats_.GetValue();
        }
        return coroutine_dump_stats_.GetValue();
    }

    void SetCoroutineDumpStats(bool value) {
        coroutine_dump_stats_.SetValue(value);
    }

    bool WasSetCoroutineDumpStats(std::string_view lang) const {
        if (lang == "ets") {
            return ets_coroutine_dump_stats_.WasSet();
        }
        return coroutine_dump_stats_.WasSet();
    }
    const std::string &GetTaskpoolMode([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsTaskpoolMode() ? ets_taskpool_mode_.GetValue() : taskpool_mode_.GetValue();
        }
        return taskpool_mode_.GetValue();
    }

    void SetTaskpoolMode(std::string value) {
        taskpool_mode_.SetValue(std::move(value));
    }

    bool WasSetTaskpoolMode(std::string_view lang) const {
        if (lang == "ets") {
            return ets_taskpool_mode_.WasSet();
        }
        return taskpool_mode_.WasSet();
    }
    const arg_list_t &GetNativeLibraryPath([[maybe_unused]] std::string_view lang = "") const {
        if (lang == "ets") {
            return WasSetEtsNativeLibraryPath() ? ets_native_library_path_.GetValue() : native_library_path_.GetValue();
        }
        return native_library_path_.GetValue();
    }

    void SetNativeLibraryPath(arg_list_t value) {
        native_library_path_.SetValue(std::move(value));
    }

    bool WasSetNativeLibraryPath(std::string_view lang) const {
        if (lang == "ets") {
            return ets_native_library_path_.WasSet();
        }
        return native_library_path_.WasSet();
    }
    bool IsListUnhandledOnExitPromises([[maybe_unused]] std::string_view lang = "") const {
        return list_unhandled_on_exit_promises_.GetValue();
    }

    void SetListUnhandledOnExitPromises(bool value) {
        list_unhandled_on_exit_promises_.SetValue(value);
    }

    bool WasSetListUnhandledOnExitPromises([[maybe_unused]] std::string_view lang = "") const {
        return list_unhandled_on_exit_promises_.WasSet();
    }
    bool IsListUnhandledOnExitJobs([[maybe_unused]] std::string_view lang = "") const {
        return list_unhandled_on_exit_jobs_.GetValue();
    }

    void SetListUnhandledOnExitJobs(bool value) {
        list_unhandled_on_exit_jobs_.SetValue(value);
    }

    bool WasSetListUnhandledOnExitJobs([[maybe_unused]] std::string_view lang = "") const {
        return list_unhandled_on_exit_jobs_.WasSet();
    }
    bool IsListUnhandledOnExit([[maybe_unused]] std::string_view lang = "") const {
        return list_unhandled_on_exit_.GetValue();
    }

    void SetListUnhandledOnExit(bool value) {
        list_unhandled_on_exit_.SetValue(value);
    }

    bool WasSetListUnhandledOnExit([[maybe_unused]] std::string_view lang = "") const {
        return list_unhandled_on_exit_.WasSet();
    }
// NOLINTNEXTLINE(readability-function-size)
    std::optional<Error> Validate() const {
        {
            std::unordered_set<std::string> possible_values{R"(core)", R"(ets)"};
            const auto &values = boot_intrinsic_spaces_.GetValue();
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --boot-intrinsic-spaces: invalid value: '" + value + \
                                 R"('. Possible values: ["core", "ets"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(core)", R"(ets)"};
            const auto &values = boot_class_spaces_.GetValue();
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --boot-class-spaces: invalid value: '" + value + \
                                 R"('. Possible values: ["core", "ets"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(core)", R"(ets)"};
            std::vector<std::string> values{runtime_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --runtime-type: invalid value: '" + value + \
                                 R"('. Possible values: ["core", "ets"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(core)", R"(ets)"};
            const auto &values = load_runtimes_.GetValue();
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --load-runtimes: invalid value: '" + value + \
                                 R"('. Possible values: ["core", "ets"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(all)", R"(alloc)", R"(mm-obj-events)", R"(classlinker)", R"(common)", R"(core)", R"(gc)", R"(gc_trigger)", R"(reference_processor)", R"(interpreter)", R"(compiler)", R"(pandafile)", R"(memorypool)", R"(runtime)", R"(trace)", R"(debugger)", R"(interop)", R"(verifier)", R"(compilation_queue)", R"(aot)", R"(events)", R"(scheduler)", R"(coroutines)"};
            const auto &values = log_components_.GetValue();
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --log-components: invalid value: '" + value + \
                                 R"('. Possible values: ["all", "alloc", "mm-obj-events", "classlinker", "common", "core", "gc", "gc_trigger", "reference_processor", "interpreter", "compiler", "pandafile", "memorypool", "runtime", "trace", "debugger", "interop", "verifier", "compilation_queue", "aot", "events", "scheduler", "coroutines"])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{compiler_nullcheck_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --compiler-nullcheck: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{reference_dump_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --reference-dump: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{signal_catcher_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --signal-catcher: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{signal_handler_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --signal-handler: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{sigquit_flag_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --sigquit-flag: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{sigusr1_flag_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --sigusr1-flag: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{sigusr2_flag_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --sigusr2-flag: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{mobile_log_flag_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --mobile-log-flag: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<uint64_t> possible_values{0, 1};
            std::vector<uint64_t> values{dfx_log_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --dfx-log: invalid value: '" + std::to_string(value) + \
                                 R"('. Possible values: [0, 1])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(epsilon)", R"(epsilon-g1)", R"(stw)", R"(g1-gc)", R"(cmc-gc)", R"(gen-gc)"};
            std::vector<std::string> values{ets_gc_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --ets.gc-type: invalid value: '" + value + \
                                 R"('. Possible values: ["epsilon", "epsilon-g1", "stw", "g1-gc", "cmc-gc", "gen-gc"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(epsilon)", R"(epsilon-g1)", R"(stw)", R"(g1-gc)", R"(cmc-gc)", R"(gen-gc)"};
            std::vector<std::string> values{gc_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --gc-type: invalid value: '" + value + \
                                 R"('. Possible values: ["epsilon", "epsilon-g1", "stw", "g1-gc", "cmc-gc", "gen-gc"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(heap-trigger-test)", R"(heap-trigger)", R"(adaptive-heap-trigger)", R"(trigger-heap-occupancy)", R"(no-gc-for-start-up)", R"(debug)", R"(debug-never)", R"(pause-time-goal-trigger)"};
            std::vector<std::string> values{ets_gc_trigger_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --ets.gc-trigger-type: invalid value: '" + value + \
                                 R"('. Possible values: ["heap-trigger-test", "heap-trigger", "adaptive-heap-trigger", "trigger-heap-occupancy", "no-gc-for-start-up", "debug", "debug-never", "pause-time-goal-trigger"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(heap-trigger-test)", R"(heap-trigger)", R"(adaptive-heap-trigger)", R"(trigger-heap-occupancy)", R"(no-gc-for-start-up)", R"(debug)", R"(debug-never)", R"(pause-time-goal-trigger)"};
            std::vector<std::string> values{gc_trigger_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --gc-trigger-type: invalid value: '" + value + \
                                 R"('. Possible values: ["heap-trigger-test", "heap-trigger", "adaptive-heap-trigger", "trigger-heap-occupancy", "no-gc-for-start-up", "debug", "debug-never", "pause-time-goal-trigger"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(default)", R"(true)", R"(false)"};
            std::vector<std::string> values{g1_track_freed_objects_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --g1-track-freed-objects: invalid value: '" + value + \
                                 R"('. Possible values: ["default", "true", "false"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(debug)", R"(info)", R"(warning)", R"(error)", R"(fatal)"};
            std::vector<std::string> values{log_level_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --log-level: invalid value: '" + value + \
                                 R"('. Possible values: ["debug", "info", "warning", "error", "fatal"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(std)", R"(file)", R"(fast-file)", R"(dummy)"};
            std::vector<std::string> values{log_stream_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --log-stream: invalid value: '" + value + \
                                 R"('. Possible values: ["std", "file", "fast-file", "dummy"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(simple)", R"(counter-priority)", R"(aged-counter-priority)"};
            std::vector<std::string> values{compiler_queue_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --compiler-queue-type: invalid value: '" + value + \
                                 R"('. Possible values: ["simple", "counter-priority", "aged-counter-priority"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(panda_allocators)", R"(malloc)", R"(default)"};
            std::vector<std::string> values{internal_allocator_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --internal-allocator-type: invalid value: '" + value + \
                                 R"('. Possible values: ["panda_allocators", "malloc", "default"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(none)", R"(csv)", R"(memory)", R"(log)"};
            std::vector<std::string> values{events_output_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --events-output: invalid value: '" + value + \
                                 R"('. Possible values: ["none", "csv", "memory", "log"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(no-native-gc-trigger)", R"(simple-strategy)"};
            std::vector<std::string> values{ets_native_gc_trigger_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --ets.native-gc-trigger-type: invalid value: '" + value + \
                                 R"('. Possible values: ["no-native-gc-trigger", "simple-strategy"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(no-native-gc-trigger)", R"(simple-strategy)"};
            std::vector<std::string> values{native_gc_trigger_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --native-gc-trigger-type: invalid value: '" + value + \
                                 R"('. Possible values: ["no-native-gc-trigger", "simple-strategy"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(disabled)", R"(on-the-fly)", R"(ahead-of-time)"};
            std::vector<std::string> values{verification_mode_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --verification-mode: invalid value: '" + value + \
                                 R"('. Possible values: ["disabled", "on-the-fly", "ahead-of-time"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(pre)", R"(into)", R"(post)", R"(before_g1_concurrent)", R"(fail_on_verification)"};
            const auto &values = heap_verifier_.GetValue();
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --heap-verifier: invalid value: '" + value + \
                                 R"('. Possible values: ["pre", "into", "post", "before_g1_concurrent", "fail_on_verification"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(cpp)", R"(irtoc)", R"(llvm)"};
            std::vector<std::string> values{interpreter_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --interpreter-type: invalid value: '" + value + \
                                 R"('. Possible values: ["cpp", "irtoc", "llvm"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(threadpool)", R"(taskmanager)"};
            std::vector<std::string> values{workers_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --workers-type: invalid value: '" + value + \
                                 R"('. Possible values: ["threadpool", "taskmanager"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(no-task-stats)", R"(light-task-stats)"};
            std::vector<std::string> values{task_stats_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --task-stats-type: invalid value: '" + value + \
                                 R"('. Possible values: ["no-task-stats", "light-task-stats"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(default)", R"(force)", R"(never)"};
            std::vector<std::string> values{ets_xgc_trigger_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --ets.xgc-trigger-type: invalid value: '" + value + \
                                 R"('. Possible values: ["default", "force", "never"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(default)", R"(force)", R"(never)"};
            std::vector<std::string> values{xgc_trigger_type_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --xgc-trigger-type: invalid value: '" + value + \
                                 R"('. Possible values: ["default", "force", "never"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(threaded)", R"(stackful)"};
            std::vector<std::string> values{ets_coroutine_impl_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --ets.coroutine-impl: invalid value: '" + value + \
                                 R"('. Possible values: ["threaded", "stackful"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(threaded)", R"(stackful)"};
            std::vector<std::string> values{coroutine_impl_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --coroutine-impl: invalid value: '" + value + \
                                 R"('. Possible values: ["threaded", "stackful"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(eaworker)", R"(launch)"};
            std::vector<std::string> values{ets_taskpool_mode_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --ets.taskpool-mode: invalid value: '" + value + \
                                 R"('. Possible values: ["eaworker", "launch"])");
                }
            }
        }
        {
            std::unordered_set<std::string> possible_values{R"(eaworker)", R"(launch)"};
            std::vector<std::string> values{taskpool_mode_.GetValue()};
            for (const auto &value : values) {
                if (possible_values.find(value) == possible_values.cend()) {
                    return Error("argument --taskpool-mode: invalid value: '" + value + \
                                 R"('. Possible values: ["eaworker", "launch"])");
                }
            }
        }
        return {};
    }

private:
    bool WasSetEtsRunGcInPlace() const {
        return ets_run_gc_in_place_.WasSet();
    }
    bool WasSetEtsGcType() const {
        return ets_gc_type_.WasSet();
    }
    bool WasSetEtsGcTriggerType() const {
        return ets_gc_trigger_type_.WasSet();
    }
    bool WasSetEtsSkipStartupGcCount() const {
        return ets_skip_startup_gc_count_.WasSet();
    }
    bool WasSetEtsGcDebugTriggerStart() const {
        return ets_gc_debug_trigger_start_.WasSet();
    }
    bool WasSetEtsGcDumpHeap() const {
        return ets_gc_dump_heap_.WasSet();
    }
    bool WasSetEtsGcEnableTracing() const {
        return ets_gc_enable_tracing_.WasSet();
    }
    bool WasSetEtsNativeGcTriggerType() const {
        return ets_native_gc_trigger_type_.WasSet();
    }
    bool WasSetEtsEnableFastHeapVerifier() const {
        return ets_enable_fast_heap_verifier_.WasSet();
    }
    bool WasSetEtsConcurrentGcEnabled() const {
        return ets_concurrent_gc_enabled_.WasSet();
    }
    bool WasSetEtsXgcTriggerType() const {
        return ets_xgc_trigger_type_.WasSet();
    }
    bool WasSetEtsTaskpoolSupportInterop() const {
        return ets_taskpool_support_interop_.WasSet();
    }
    bool WasSetEtsFailOnHeapVerification() const {
        return ets_fail_on_heap_verification_.WasSet();
    }
    bool WasSetEtsPreGcHeapVerifyEnabled() const {
        return ets_pre_gc_heap_verify_enabled_.WasSet();
    }
    bool WasSetEtsIntoGcHeapVerifyEnabled() const {
        return ets_into_gc_heap_verify_enabled_.WasSet();
    }
    bool WasSetEtsPostGcHeapVerifyEnabled() const {
        return ets_post_gc_heap_verify_enabled_.WasSet();
    }
    bool WasSetEtsEnableParalledYoungGc() const {
        return ets_enable_paralled_young_gc_.WasSet();
    }
    bool WasSetEtsCoroutineImpl() const {
        return ets_coroutine_impl_.WasSet();
    }
    bool WasSetEtsCoroutineWorkersCount() const {
        return ets_coroutine_workers_count_.WasSet();
    }
    bool WasSetEtsCoroutineEWorkersLimit() const {
        return ets_coroutine_e_workers_limit_.WasSet();
    }
    bool WasSetEtsCoroutineDumpStats() const {
        return ets_coroutine_dump_stats_.WasSet();
    }
    bool WasSetEtsTaskpoolMode() const {
        return ets_taskpool_mode_.WasSet();
    }
    bool WasSetEtsNativeLibraryPath() const {
        return ets_native_library_path_.WasSet();
    }

    static std::string GetExeDir(const std::string &exe_path) {
#ifdef PANDA_TARGET_WINDOWS
        const char preferred_separator = '\\';
#else
        const char preferred_separator = '/';
#endif
        auto pos = exe_path.find_last_of(preferred_separator);
        if (pos == std::string::npos) {
            return ".";
        }
        return exe_path.substr(0, pos);
    }

    static constexpr uint32_t FULL_GC_BOMBING_FREQUENCY_DEFAULT = 0;

    static constexpr uint32_t COMPILER_HOTNESS_THRESHOLD_DEFAULT = 3000;

    static constexpr uint32_t COMPILER_PROFILING_THRESHOLD_DEFAULT = 1500;

    static constexpr uint32_t SAMPLING_PROFILER_INTERVAL_DEFAULT = 500;

    static constexpr uint32_t DEBUGGER_PORT_DEFAULT = 19015;

    static constexpr uint64_t COMPILER_NULLCHECK_DEFAULT = 1;

    static constexpr uint64_t REFERENCE_DUMP_DEFAULT = 1;

    static constexpr uint64_t SIGNAL_CATCHER_DEFAULT = 1;

    static constexpr uint64_t SIGNAL_HANDLER_DEFAULT = 1;

    static constexpr uint64_t SIGQUIT_FLAG_DEFAULT = 1;

    static constexpr uint64_t SIGUSR1_FLAG_DEFAULT = 1;

    static constexpr uint64_t SIGUSR2_FLAG_DEFAULT = 1;

    static constexpr uint64_t MOBILE_LOG_FLAG_DEFAULT = 1;

    static constexpr uint64_t DFX_LOG_DEFAULT = 0;

    static constexpr uint32_t GC_TRIGGER_PERCENT_THRESHOLD_DEFAULT = 15;

    static constexpr uint32_t GC_TRIGGER_ADAPTIVE_MULTIPLIER_DEFAULT = 3;

    static constexpr uint32_t MAX_TRIGGER_PERCENT_DEFAULT = 45;

    static constexpr uint32_t ETS_SKIP_STARTUP_GC_COUNT_DEFAULT = 10;

    static constexpr uint32_t SKIP_STARTUP_GC_COUNT_DEFAULT = 10;

    static constexpr uint64_t INIT_YOUNG_SPACE_SIZE_DEFAULT = 4194304;

    static constexpr uint64_t YOUNG_SPACE_SIZE_DEFAULT = 4194304;

    static constexpr uint64_t YOUNG_SHARED_SPACE_SIZE_DEFAULT = 524288;

    static constexpr uint64_t MIN_EXTRA_HEAP_SIZE_DEFAULT = 5242880;

    static constexpr uint64_t MAX_EXTRA_HEAP_SIZE_DEFAULT = 8388608;

    static constexpr uint64_t ETS_GC_DEBUG_TRIGGER_START_DEFAULT = 0;

    static constexpr uint64_t GC_DEBUG_TRIGGER_START_DEFAULT = 0;

    static constexpr uint32_t G1_REGION_GARBAGE_RATE_THRESHOLD_DEFAULT = 52;

    static constexpr uint32_t G1_NUMBER_OF_TENURED_REGIONS_AT_MIXED_COLLECTION_DEFAULT = 20;

    static constexpr uint64_t GC_MARKING_STACK_NEW_TASKS_FREQUENCY_DEFAULT = 10000000;

    static constexpr uint32_t GC_ROOT_MARKING_STACK_MAX_SIZE_DEFAULT = 186;

    static constexpr uint32_t GC_WORKERS_MARKING_STACK_MAX_SIZE_DEFAULT = 200;

    static constexpr uint64_t LONG_GC_THRESHOLD_NS_DEFAULT = 40000000;

    static constexpr uint32_t G1_MIN_CONCURRENT_CARDS_TO_PROCESS_DEFAULT = 2;

    static constexpr uint32_t G1_HOT_CARDS_PROCESSING_FREQUENCY_DEFAULT = 7;

    static constexpr uint32_t G1_PROMOTION_REGION_ALIVE_RATE_DEFAULT = 75;

    static constexpr uint32_t G1_FULL_GC_REGION_FRAGMENTATION_RATE_DEFAULT = 10;

    static constexpr uint32_t MAX_GC_PAUSE_DEFAULT = 10;

    static constexpr uint32_t GC_PAUSE_INTERVAL_DEFAULT = 11;

    static constexpr uint64_t INIT_TLAB_SIZE_DEFAULT = 4096;

    static constexpr uint64_t MAX_TLAB_SIZE_DEFAULT = 16384;

    static constexpr uint64_t INIT_HEAP_SIZE_LIMIT_DEFAULT = 536870912;

    static constexpr uint32_t HEAP_SIZE_LIMIT_DEFAULT = 536870912;

    static constexpr uint64_t FRAMES_MEMORY_SIZE_LIMIT_DEFAULT = 2147483648;

    static constexpr uint32_t MIN_HEAP_FREE_PERCENTAGE_DEFAULT = 30;

    static constexpr uint32_t MAX_HEAP_FREE_PERCENTAGE_DEFAULT = 70;

    static constexpr uint64_t CODE_CACHE_SIZE_LIMIT_DEFAULT = 33554432;

    static constexpr uint64_t COMPILER_MEMORY_SIZE_LIMIT_DEFAULT = 268435456;

    static constexpr uint32_t COMPILER_TASK_LIFE_SPAN_DEFAULT = 500;

    static constexpr uint32_t COMPILER_QUEUE_MAX_LENGTH_DEFAULT = 100;

    static constexpr uint32_t COMPILER_EPOCH_DURATION_DEFAULT = 500;

    static constexpr uint32_t COMPILER_DEATH_COUNTER_VALUE_DEFAULT = 500;

    static constexpr uint32_t FINALIZER_TIMEOUT_MS_DEFAULT = 10000;

    static constexpr uint32_t MAX_FREE_DEFAULT = 8388608;

    static constexpr uint32_t PROFILESAVER_SLEEPING_TIME_MS_DEFAULT = 40000;

    static constexpr uint64_t PROFILESAVER_DELTA_NUMBER_THRESHOLD_DEFAULT = 0;

    static constexpr uint32_t VERIFICATION_THREADS_DEFAULT = 1;

    static constexpr uint32_t MAX_GLOBAL_REF_SIZE_DEFAULT = 65535;

    static constexpr uint64_t AOT_STRING_GC_ROOTS_LIMIT_DEFAULT = 1000;

    static constexpr uint32_t RESOLVE_STRING_AOT_THRESHOLD_DEFAULT = 1;

    static constexpr uint32_t IGNORE_DAEMON_MEMORY_LEAKS_THRESHOLD_DEFAULT = 0;

    static constexpr uint32_t INTRUSIVE_TEST_DEFAULT = 0;

    static constexpr uint32_t CALL_PROFILING_TABLE_SIZE_DEFAULT = 1000;

    static constexpr uint32_t COROUTINE_STACK_SIZE_PAGES_DEFAULT = 64;

    static constexpr uint64_t COROUTINES_USER_LIMIT_DEFAULT = 0;

    static constexpr uint32_t XGC_MIN_TRIGGER_THRESHOLD_DEFAULT = 20480;

    static constexpr uint32_t XGC_TRIGGER_PERCENT_THRESHOLD_DEFAULT = 20;

    static constexpr uint32_t ETS_COROUTINE_WORKERS_COUNT_DEFAULT = 0;

    static constexpr uint32_t COROUTINE_WORKERS_COUNT_DEFAULT = 0;

    static constexpr uint32_t ETS_COROUTINE_E_WORKERS_LIMIT_DEFAULT = 64;

    static constexpr uint32_t COROUTINE_E_WORKERS_LIMIT_DEFAULT = 64;

    std::string exe_dir_;
    PandArg<bool> version_{"version", false, R"(Print version and exit. Default: false)"};
    PandArg<arg_list_t> boot_panda_files_{"boot-panda-files", {exe_dir_ + R"(/../pandastdlib/arkstdlib.abc)"}, R"(Boot panda files separated by colon. Default: ["$ORIGIN/../pandastdlib/arkstdlib.abc"])", ":"};
    PandArg<arg_list_t> panda_files_{"panda-files", {}, R"(Panda files separated by colon which is not within boot-panda-files. Default: [])", ":"};
    PandArg<arg_list_t> boot_intrinsic_spaces_{"boot-intrinsic-spaces", {R"(core)", R"(ets)"}, R"(Load specified intrinsic spaces. This option is for fine tuning. Use load-runtimes instead. Possible values: ["core", "ets"]. Default: ["core", "ets"])", ":"};
    PandArg<arg_list_t> boot_class_spaces_{"boot-class-spaces", {R"(core)"}, R"(Load specified class spaces. This option is for fine tuning. Use load-runtimes instead. Possible values: ["core", "ets"]. Default: ["core"])", ":"};
    PandArg<std::string> runtime_type_{"runtime-type", R"(core)", R"(Runtime type. This option is for fine tuning. Use load-runtimes instead. Possible values: ["core", "ets"]. Default: "core")"};
    PandArg<arg_list_t> load_runtimes_{"load-runtimes", {R"(core)"}, R"(Load specified class and intrinsic spaces and define runtime type. Possible values: ["core", "ets"]. Default: ["core"])", ":"};
    PandArg<bool> runtime_compressed_strings_enabled_{"runtime-compressed-strings-enabled", true, R"(Enable/disable compressed strings. Default: true)"};
    PandArg<bool> explicit_concurrent_gc_enabled_{"explicit-concurrent-gc-enabled", true, R"(Enable/disable explicit GC run in concurrent. Default: true)"};
    PandArg<bool> ets_run_gc_in_place_{"ets.run-gc-in-place", false, R"(Enable/disable running GC only in place. Only for ets. Default: false)"};
    PandArg<bool> run_gc_in_place_{"run-gc-in-place", false, R"(Enable/disable running GC only in place. Default: false)"};
    PandArg<uint32_t> full_gc_bombing_frequency_{"full-gc-bombing-frequency", FULL_GC_BOMBING_FREQUENCY_DEFAULT, R"(Switch on running Full GC collection instead of the one in the trigger queue in the GC thread. Value means frequency - each N collection in the GC thread will be a full collection. Can't be use with run-gc-in-place. Default: 0)"};
    PandArg<bool> run_gc_every_safepoint_{"run-gc-every-safepoint", false, R"(Run GC on every safepoint. GC will be run only if we use gc-trigger-type=debug and run-gc-in-place=true. Default: false)"};
    PandArg<bool> compiler_enable_jit_{"compiler-enable-jit", true, R"(Enables/disables JIT compiler. Default: true)"};
    PandArg<uint32_t> compiler_hotness_threshold_{"compiler-hotness-threshold", COMPILER_HOTNESS_THRESHOLD_DEFAULT, R"(Threshold for "hotness" counter of the method after that it will be compiled. Default: 3000)"};
    PandArg<uint32_t> compiler_profiling_threshold_{"compiler-profiling-threshold", COMPILER_PROFILING_THRESHOLD_DEFAULT, R"(Threshold to start method profiling. Default: 1500)"};
    PandArg<bool> compiler_enable_osr_{"compiler-enable-osr", true, R"(Enables/disables OSR compilation. Default: true)"};
    PandArg<std::string> debugger_library_path_{"debugger-library-path", R"()", R"(Path to debugger library. Default: "")"};
    PandArg<bool> debugger_enable_{"debugger-enable", false, R"(Is debugger enabled on runtime create. Default: false)"};
    PandArg<bool> sampling_profiler_create_{"sampling-profiler-create", false, R"(Is the sampling profiler created and available during runtime execution. Default: false)"};
    PandArg<bool> profile_branches_{"profile-branches", false, R"(whether to collect detailed branch statistics data for PGO. Default: false)"};
    PandArg<bool> sampling_profiler_startup_run_{"sampling-profiler-startup-run", false, R"(Is the sampling profiler runned on runtime startup. Default: false)"};
    PandArg<uint32_t> sampling_profiler_interval_{"sampling-profiler-interval", SAMPLING_PROFILER_INTERVAL_DEFAULT, R"(Sampling profiler interval in microseconds. Default: 500)"};
    PandArg<std::string> sampling_profiler_output_file_{"sampling-profiler-output-file", R"()", R"(Name of file to collect trace in .aspt format. Default: "")"};
    PandArg<uint32_t> debugger_port_{"debugger-port", DEBUGGER_PORT_DEFAULT, R"(Port for serving debugger clients via socket. Default: 19015)"};
    PandArg<bool> debugger_break_on_start_{"debugger-break-on-start", false, R"(Whether to break threads on creation or not. Default: false)"};
    PandArg<arg_list_t> log_components_{"log-components", {R"(all)"}, R"([DEPRECATED] [DEPRECATED] Option was moved to libarkbase/utils/logger_options.yaml, use logger::Options instead of runtime options. Possible values: ["all", "alloc", "mm-obj-events", "classlinker", "common", "core", "gc", "gc_trigger", "reference_processor", "interpreter", "compiler", "pandafile", "memorypool", "runtime", "trace", "debugger", "interop", "verifier", "compilation_queue", "aot", "events", "scheduler", "coroutines"]. Default: ["all"])", ":"};
    PandArg<uint64_t> compiler_nullcheck_{"compiler-nullcheck", COMPILER_NULLCHECK_DEFAULT, R"(Dfx option for compiler-nullcheck. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> reference_dump_{"reference-dump", REFERENCE_DUMP_DEFAULT, R"(Dfx option for reference-dump. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> signal_catcher_{"signal-catcher", SIGNAL_CATCHER_DEFAULT, R"(Dfx option for signal-catcher. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> signal_handler_{"signal-handler", SIGNAL_HANDLER_DEFAULT, R"(Dfx option for signal-handler. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> sigquit_flag_{"sigquit-flag", SIGQUIT_FLAG_DEFAULT, R"(Dfx option for sigquit. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> sigusr1_flag_{"sigusr1-flag", SIGUSR1_FLAG_DEFAULT, R"(Dfx option for sigusr1. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> sigusr2_flag_{"sigusr2-flag", SIGUSR2_FLAG_DEFAULT, R"(Dfx option for sigusr2. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> mobile_log_flag_{"mobile-log-flag", MOBILE_LOG_FLAG_DEFAULT, R"(Dfx option for mobile-log. Possible values: [0, 1]. Default: 1)"};
    PandArg<uint64_t> dfx_log_{"dfx-log", DFX_LOG_DEFAULT, R"(Dfx option for dfx log. Possible values: [0, 1]. Default: 0)"};
    PandArg<std::string> ets_gc_type_{"ets.gc-type", R"(g1-gc)", R"(Type of used GC. Only for ets. Possible values: ["epsilon", "epsilon-g1", "stw", "g1-gc", "cmc-gc", "gen-gc"]. Default: "g1-gc")"};
    PandArg<std::string> gc_type_{"gc-type", R"(g1-gc)", R"(Type of used GC. Possible values: ["epsilon", "epsilon-g1", "stw", "g1-gc", "cmc-gc", "gen-gc"]. Default: "g1-gc")"};
    PandArg<bool> ic_enable_{"ic-enable", true, R"(switch of inline cache. Default: true)"};
    PandArg<std::string> ets_gc_trigger_type_{"ets.gc-trigger-type", R"(heap-trigger)", R"(Type of used GC trigger. Only for ets. Possible values: ["heap-trigger-test", "heap-trigger", "adaptive-heap-trigger", "trigger-heap-occupancy", "no-gc-for-start-up", "debug", "debug-never", "pause-time-goal-trigger"]. Default: "heap-trigger")"};
    PandArg<std::string> gc_trigger_type_{"gc-trigger-type", R"(heap-trigger)", R"(Type of used GC trigger. Possible values: ["heap-trigger-test", "heap-trigger", "adaptive-heap-trigger", "trigger-heap-occupancy", "no-gc-for-start-up", "debug", "debug-never", "pause-time-goal-trigger"]. Default: "heap-trigger")"};
    PandArg<bool> log_detailed_gc_info_enabled_{"log-detailed-gc-info-enabled", false, R"(If print INFO log to get more detailed information in GC. Default: false)"};
    PandArg<bool> log_detailed_gc_compaction_info_enabled_{"log-detailed-gc-compaction-info-enabled", false, R"(If print INFO log to get more detailed compaction/promotion information per region in GC. Default: false)"};
    PandArg<uint32_t> gc_trigger_percent_threshold_{"gc-trigger-percent-threshold", GC_TRIGGER_PERCENT_THRESHOLD_DEFAULT, R"(Percent of heap for threshold increasing. Default: 15)"};
    PandArg<uint32_t> gc_trigger_adaptive_multiplier_{"gc-trigger-adaptive-multiplier", GC_TRIGGER_ADAPTIVE_MULTIPLIER_DEFAULT, R"(Adjust jump from too frequent gc. New jump calculate as gc-trigger-adaptive-multiplier * max-max-extra-heap-size. Default: 3)"};
    PandArg<uint32_t> max_trigger_percent_{"max-trigger-percent", MAX_TRIGGER_PERCENT_DEFAULT, R"(Percent of maximum heap size is used as threshold for trigger-heap-occupancy. Default: 45)"};
    PandArg<uint32_t> ets_skip_startup_gc_count_{"ets.skip-startup-gc-count", ETS_SKIP_STARTUP_GC_COUNT_DEFAULT, R"(No stw gc count for no-gc-for-start-up. Only for ets. Default: 10)"};
    PandArg<uint32_t> skip_startup_gc_count_{"skip-startup-gc-count", SKIP_STARTUP_GC_COUNT_DEFAULT, R"(No stw gc count for no-gc-for-start-up. Default: 10)"};
    PandArg<bool> gc_use_nth_alloc_trigger_{"gc-use-nth-alloc-trigger", false, R"(Allow to trigger GC on n-th allocation. Default: false)"};
    PandArg<uint64_t> init_young_space_size_{"init-young-space-size", INIT_YOUNG_SPACE_SIZE_DEFAULT, R"(Initial young space size. Default: 4194304)"};
    PandArg<uint64_t> young_space_size_{"young-space-size", YOUNG_SPACE_SIZE_DEFAULT, R"(Young space size. Default: 4194304)"};
    PandArg<uint64_t> young_shared_space_size_{"young-shared-space-size", YOUNG_SHARED_SPACE_SIZE_DEFAULT, R"(How much space in young-gen are shared (this space is not used for tlabs). Default: 524288)"};
    PandArg<uint64_t> min_extra_heap_size_{"min-extra-heap-size", MIN_EXTRA_HEAP_SIZE_DEFAULT, R"(Minimum extra heap size for trigger gc. Default: 5242880)"};
    PandArg<uint64_t> max_extra_heap_size_{"max-extra-heap-size", MAX_EXTRA_HEAP_SIZE_DEFAULT, R"(Maximum extra heap size for trigger gc. Default: 8388608)"};
    PandArg<uint64_t> ets_gc_debug_trigger_start_{"ets.gc-debug-trigger-start", ETS_GC_DEBUG_TRIGGER_START_DEFAULT, R"(First iteration to start returning true in debug trigger. Only for ets. Default: 0)"};
    PandArg<uint64_t> gc_debug_trigger_start_{"gc-debug-trigger-start", GC_DEBUG_TRIGGER_START_DEFAULT, R"(First iteration to start returning true in debug trigger. Default: 0)"};
    PandArg<bool> ets_gc_dump_heap_{"ets.gc-dump-heap", false, R"(Dump heap before and after GC. Only for ets. Default: false)"};
    PandArg<bool> gc_dump_heap_{"gc-dump-heap", false, R"(Dump heap before and after GC. Default: false)"};
    PandArg<uint32_t> gc_workers_count_;
    PandArg<bool> manage_gc_threads_affinity_{"manage-gc-threads-affinity", true, R"(Manage GC Threads affinity on cores. Default: true)"};
    PandArg<bool> use_weak_cpu_for_gc_concurrent_{"use-weak-cpu-for-gc-concurrent", false, R"(Set GC Thread on weak cores during concurrent phases. Default: false)"};
    PandArg<uint32_t> g1_region_garbage_rate_threshold_{"g1-region-garbage-rate-threshold", G1_REGION_GARBAGE_RATE_THRESHOLD_DEFAULT, R"(Specify garbage rate threshold of a tenured region to be included into a mixed collection. Default: 52)"};
    PandArg<uint32_t> g1_number_of_tenured_regions_at_mixed_collection_{"g1-number-of-tenured-regions-at-mixed-collection", G1_NUMBER_OF_TENURED_REGIONS_AT_MIXED_COLLECTION_DEFAULT, R"(Specify a max number of tenured regions which can be collected at mixed collection in G1GC. Default: 20)"};
    PandArg<std::string> g1_track_freed_objects_{"g1-track-freed-objects", R"(default)", R"(Specify whether G1GC tracks object removing (i.e. update objects count in memstats and log removed objects). Default means true on Release and false otherwise. If the value is true G1GC doesn't delete classes in concurrent phase because it needs to know object size. Possible values: ["default", "true", "false"]. Default: "default")"};
    PandArg<uint64_t> gc_marking_stack_new_tasks_frequency_{"gc-marking-stack-new-tasks-frequency", GC_MARKING_STACK_NEW_TASKS_FREQUENCY_DEFAULT, R"(Limit the creation rate of tasks during marking in nanoseconds. if average task creation during marking is less than this value - it increases the stack size limit to create tasks less frequently. Default: 10000000)"};
    PandArg<uint32_t> gc_root_marking_stack_max_size_{"gc-root-marking-stack-max-size", GC_ROOT_MARKING_STACK_MAX_SIZE_DEFAULT, R"(The max stack size for root marking in main thread, if it exceeded, we will send a new task to workers. 0 means unlimited. Default: 186)"};
    PandArg<uint32_t> gc_workers_marking_stack_max_size_{"gc-workers-marking-stack-max-size", GC_WORKERS_MARKING_STACK_MAX_SIZE_DEFAULT, R"(The max stack size for marking stage proceed in workers threads, if it exceeded, we will send a new task to other workers. 0 means unlimited. Default: 200)"};
    PandArg<bool> gc_parallel_marking_enabled_{"gc-parallel-marking-enabled", true, R"(Enable parallel marking in GC if it is supported (now it is G1 and STW). If we don't have gc workers, this options will be ignored. Default: true)"};
    PandArg<bool> gc_parallel_compacting_enabled_{"gc-parallel-compacting-enabled", true, R"(Enable parallel compacting in GC if it is supported (now it is G1). If we don't have gc workers, this options will be ignored. Default: true)"};
    PandArg<bool> gc_parallel_ref_updating_enabled_{"gc-parallel-ref-updating-enabled", true, R"(Enable parallel references updating in GC if it is supported (now it is G1). If we don't have gc workers, this options will be ignored. Default: true)"};
    PandArg<uint64_t> long_gc_threshold_ns_{"long-gc-threshold-ns", LONG_GC_THRESHOLD_NS_DEFAULT, R"(Specify the threshold for the duration of Full GC before exceeding the execution time. Default: 40000000)"};
    PandArg<bool> g1_single_pass_compaction_enabled_{"g1-single-pass-compaction-enabled", true, R"(Enable single pass compaction mode for G1 GC if it is supported by VM implementation. Default: true)"};
    PandArg<bool> reference_processor_enable_{"reference-processor-enable", true, R"(Enables/disables ReferenceProcessor. Default: true)"};
    PandArg<std::string> log_level_{"log-level", R"(error)", R"([DEPRECATED] [DEPRECATED] Option was moved to libarkbase/utils/logger_options.yaml, use logger::Options instead of runtime options. Possible values: ["debug", "info", "warning", "error", "fatal"]. Default: "error")"};
    PandArg<std::string> log_stream_{"log-stream", R"(std)", R"([DEPRECATED] [DEPRECATED] Option was moved to libarkbase/utils/logger_options.yaml, use logger::Options instead of runtime options. Possible values: ["std", "file", "fast-file", "dummy"]. Default: "std")"};
    PandArg<std::string> log_file_{"log-file", R"()", R"([DEPRECATED] [DEPRECATED] Option was moved to libarkbase/utils/logger_options.yaml, use logger::Options instead of runtime options. Default: "")"};
    PandArg<bool> ets_gc_enable_tracing_{"ets.gc-enable-tracing", false, R"(enables/disables tracing gc. Only for ets. Default: false)"};
    PandArg<bool> gc_enable_tracing_{"gc-enable-tracing", false, R"(enables/disables tracing gc. Default: false)"};
    PandArg<bool> g1_enable_concurrent_update_remset_{"g1-enable-concurrent-update-remset", true, R"(enables/disables concurrent update remset thread. Default: true)"};
    PandArg<uint32_t> g1_min_concurrent_cards_to_process_{"g1-min-concurrent-cards-to-process", G1_MIN_CONCURRENT_CARDS_TO_PROCESS_DEFAULT, R"(Minimum number of cards to process from queue in update-remset-thread. Higher number consumes less CPU, but can cause higher pause. Default: 2)"};
    PandArg<uint32_t> g1_hot_cards_processing_frequency_{"g1-hot-cards-processing-frequency", G1_HOT_CARDS_PROCESSING_FREQUENCY_DEFAULT, R"(Frequency of proccessing hot cards in update-remset-thread. Default: 7)"};
    PandArg<uint32_t> g1_promotion_region_alive_rate_{"g1-promotion-region-alive-rate", G1_PROMOTION_REGION_ALIVE_RATE_DEFAULT, R"(Minimum percentage of alive bytes in young region to promote it into tenured without moving. 100 value means never. Default: 75)"};
    PandArg<uint32_t> g1_full_gc_region_fragmentation_rate_{"g1-full-gc-region-fragmentation-rate", G1_FULL_GC_REGION_FRAGMENTATION_RATE_DEFAULT, R"(Maximum fragmentation percentage for a tenured region with no garbage inside to skip it on full collection. If the region has bigger fragmentation, we will collect it during a full collection in spite of it has no garbage inside. 0 value means we will collect every region. Default: 10)"};
    PandArg<uint32_t> g1_pause_time_goal_max_gc_pause_{"max-gc-pause", MAX_GC_PAUSE_DEFAULT, R"(Maximum sum of G1 GC pauses during gc-pause-interval in milliseconds. Default: 10)"};
    PandArg<uint32_t> g1_pause_time_goal_gc_pause_interval_{"gc-pause-interval", GC_PAUSE_INTERVAL_DEFAULT, R"(Time interval for max-gc-pause in milliseconds. Default: 11)"};
    PandArgCompound g1_pause_time_goal_{"g1-pause-time-goal", R"(Enable G1 pause time goal. Default: "false")", {&g1_pause_time_goal_max_gc_pause_, &g1_pause_time_goal_gc_pause_interval_}};
    PandArg<bool> distributed_profiling_{"distributed-profiling", false, R"(Enable/disable collection of information for distributed profiling. Default: false)"};
    PandArg<std::string> aot_file_{"aot-file", R"()", R"(path to aot file. Default: "")"};
    PandArg<arg_list_t> aot_files_{"aot-files", {}, R"(List of aot files to be loaded. Default: [])", ":"};
    PandArg<bool> aot_verify_abs_path_{"aot-verify-abs-path", true, R"(Use absolute path to panda files in Aot verification. Default: true)"};
    PandArg<bool> adaptive_tlab_size_{"adaptive-tlab-size", true, R"(Enable/disable adaptive TLAB size according to runtime allocation statistics. Default: true)"};
    PandArg<uint64_t> init_tlab_size_{"init-tlab-size", INIT_TLAB_SIZE_DEFAULT, R"(Initial TLAB size and maximum size of object to be allocated in TLAB. TLAB size remains constant unless adaptive-tlab-size is enabled. Also, this value is used for YoungAllocMaxSize. Default: 4096)"};
    PandArg<uint64_t> max_tlab_size_{"max-tlab-size", MAX_TLAB_SIZE_DEFAULT, R"(Max TLAB size. Used when adaptive-tlab-size is enabled. Default: 16384)"};
    PandArg<bool> use_tlab_for_allocations_{"use-tlab-for-allocations", true, R"(Enable/disable TLAB using for object allocations. Now, it is ignored for all GCs. Temporary option for quick switch between modes. Default: true)"};
    PandArg<uint64_t> init_heap_size_limit_{"init-heap-size-limit", INIT_HEAP_SIZE_LIMIT_DEFAULT, R"(Initial size of pool used for objects (Xms). If it was not set explicitly then it set as heap-size-limit. Default: 536870912)"};
    PandArg<uint32_t> heap_size_limit_{"heap-size-limit", HEAP_SIZE_LIMIT_DEFAULT, R"(Max heap size. Default: 536870912)"};
    PandArg<uint64_t> internal_memory_size_limit_;
    PandArg<uint64_t> frames_memory_size_limit_{"frames-memory-size-limit", FRAMES_MEMORY_SIZE_LIMIT_DEFAULT, R"(Max internal memory used for frames in the VM. Default: 2147483648)"};
    PandArg<uint32_t> min_heap_free_percentage_{"min-heap-free-percentage", MIN_HEAP_FREE_PERCENTAGE_DEFAULT, R"(Minimum percentage of free space in heap. Must be 0 <= min-heap-free-percentage <= max-heap-free-percentage <= 100. Default: 30)"};
    PandArg<uint32_t> max_heap_free_percentage_{"max-heap-free-percentage", MAX_HEAP_FREE_PERCENTAGE_DEFAULT, R"(Maximum percentage of free space in heap. Must be 0 <= min-heap-free-percentage <= max-heap-free-percentage <= 100. Default: 70)"};
    PandArg<uint64_t> code_cache_size_limit_{"code-cache-size-limit", CODE_CACHE_SIZE_LIMIT_DEFAULT, R"(The limit for compiled code size. Default: 33554432)"};
    PandArg<uint64_t> compiler_memory_size_limit_{"compiler-memory-size-limit", COMPILER_MEMORY_SIZE_LIMIT_DEFAULT, R"(Max memory used by the compiler. Default: 268435456)"};
    PandArg<bool> print_memory_statistics_{"print-memory-statistics", false, R"(Enable/disable printing memory statistics in the end of the program. Default: false)"};
    PandArg<bool> print_gc_statistics_{"print-gc-statistics", false, R"(Enable/disable printing gc statistics in the end of the program. Default: false)"};
    PandArg<bool> no_async_jit_{"no-async-jit", false, R"(Perform compilation in the main thread or in parallel worker. Default: false)"};
    PandArg<std::string> compiler_queue_type_{"compiler-queue-type", R"(counter-priority)", R"(Type of compiler queue. Possible values: ["simple", "counter-priority", "aged-counter-priority"]. Default: "counter-priority")"};
    PandArg<uint32_t> compiler_task_life_span_{"compiler-task-life-span", COMPILER_TASK_LIFE_SPAN_DEFAULT, R"(A time in milliseconds of task life span in compiler counter priority queue. Default: 500)"};
    PandArg<uint32_t> compiler_queue_max_length_{"compiler-queue-max-length", COMPILER_QUEUE_MAX_LENGTH_DEFAULT, R"(Max length of compiler queue. Default: 100)"};
    PandArg<uint32_t> compiler_epoch_duration_{"compiler-epoch-duration", COMPILER_EPOCH_DURATION_DEFAULT, R"(Duration in milliseconds of an epoch in compiler aged counter priority queue. Default: 500)"};
    PandArg<uint32_t> compiler_death_counter_value_{"compiler-death-counter-value", COMPILER_DEATH_COUNTER_VALUE_DEFAULT, R"(Minimum value of aged counter, which will be still considered. Default: 500)"};
    PandArg<bool> limit_standard_alloc_{"limit-standard-alloc", false, R"(Limit standard allocations usage in runtime. Default: false)"};
    PandArg<std::string> internal_allocator_type_{"internal-allocator-type", R"(default)", R"(Default means using malloc for Release, and panda allocators for Debug builds. If we use malloc, we will ignore limit-standard-alloc option. Possible values: ["panda_allocators", "malloc", "default"]. Default: "default")"};
    PandArg<uint32_t> finalizer_timeout_ms_{"finalizer-timeout-ms", FINALIZER_TIMEOUT_MS_DEFAULT, R"(Set finalizer daemon watchdog time. Default: 10000)"};
    PandArg<arg_list_t> properties_{"properties", {R"(user.locale=en-US)"}, R"(command-line property settings of VM. Default: ["user.locale=en-US"])"};
    PandArg<std::string> events_output_{"events-output", R"(none)", R"(Specify events output. Possible values: ["none", "csv", "memory", "log"]. Default: "none")"};
    PandArg<std::string> events_file_{"events-file", R"(events.csv)", R"(Path to events output file (if needed). Default: "events.csv")"};
    PandArg<bool> mem_alloc_dump_exec_{"mem-alloc-dump-exec", false, R"(true if need to dump. Default: false)"};
    PandArg<std::string> mem_alloc_dump_file_{"mem-alloc-dump-file", R"(mem_dump.csv)", R"(Path to mem dump file (if needed). Default: "mem_dump.csv")"};
    PandArg<bool> startup_time_{"startup-time", false, R"(Print the start time of command execution. Default: false)"};
    PandArg<uint32_t> max_free_{"max-free", MAX_FREE_DEFAULT, R"(Trigger native memory recycling watermark, default 8 M. Default: 8388608)"};
    PandArg<std::string> ets_native_gc_trigger_type_{"ets.native-gc-trigger-type", R"(simple-strategy)", R"(Type of native gc trigger. Only for ets. Possible values: ["no-native-gc-trigger", "simple-strategy"]. Default: "simple-strategy")"};
    PandArg<std::string> native_gc_trigger_type_{"native-gc-trigger-type", R"(simple-strategy)", R"(Type of native gc trigger. Possible values: ["no-native-gc-trigger", "simple-strategy"]. Default: "simple-strategy")"};
    PandArg<bool> profiler_enabled_{"profiler-enabled", true, R"(whether open the pgo profiler when jit diabled. Default: true)"};
    PandArg<uint32_t> profilesaver_sleeping_time_ms_{"profilesaver-sleeping-time-ms", PROFILESAVER_SLEEPING_TIME_MS_DEFAULT, R"(Set wake up period time of daemon thread for profile saver. Default: 40000)"};
    PandArg<uint64_t> profilesaver_delta_number_threshold_{"profilesaver-delta-number-threshold", PROFILESAVER_DELTA_NUMBER_THRESHOLD_DEFAULT, R"(delta number threshold of newly added method or class for profile saver. Default: 0)"};
    PandArg<bool> profilesaver_enabled_{"profilesaver-enabled", false, R"(whether open the profilesaver functions. Default: false)"};
    PandArg<bool> incremental_profilesaver_enabled_{"incremental-profilesaver-enabled", false, R"(whether open the incremental profilesaver functions, only work when profiler is enabled. Default: false)"};
    PandArg<bool> start_as_zygote_{"start-as-zygote", false, R"(whether current vm is zygote. Default: false)"};
    PandArg<std::string> verification_mode_{"verification-mode", R"(ahead-of-time)", R"(Verification mode. Possible values: ["disabled", "on-the-fly", "ahead-of-time"]. Default: "ahead-of-time")"};
    PandArg<bool> verification_update_cache_{"verification-update-cache", true, R"(Whether to update verification result cache. Default: true)"};
    PandArg<uint32_t> verification_threads_{"verification-threads", VERIFICATION_THREADS_DEFAULT, R"(number of verification threads. Default: 1)"};
    PandArg<std::string> verification_config_file_{"verification-config-file", R"(default)", R"(filename with debug config for verifier. Default: "default")"};
    PandArg<std::string> verification_cache_file_{"verification-cache-file", R"()", R"(verifier cache filename. Default: "")"};
    PandArg<bool> ets_enable_fast_heap_verifier_{"ets.enable-fast-heap-verifier", true, R"(Enable fast heap verifier, which is faster than ordinary heap verifier but uses more internal memory. Only for ets. Default: true)"};
    PandArg<bool> enable_fast_heap_verifier_{"enable-fast-heap-verifier", true, R"(Enable fast heap verifier, which is faster than ordinary heap verifier but uses more internal memory. Default: true)"};
    PandArg<arg_list_t> heap_verifier_{"heap-verifier", {}, R"(parameters for heap verification. Possible values: ["pre", "into", "post", "before_g1_concurrent", "fail_on_verification"]. Default: [])", ":"};
    PandArg<uint32_t> max_global_ref_size_{"max-global-ref-size", MAX_GLOBAL_REF_SIZE_DEFAULT, R"(max size of global reference storage. Default: 65535)"};
    PandArg<bool> global_reference_size_check_enabled_{"global-reference-size-check-enabled", false, R"(whether open the global reference size check. Default: false)"};
    PandArg<bool> ets_concurrent_gc_enabled_{"ets.concurrent-gc-enabled", true, R"(whether concurrent GC is enabled. Only for ets. Default: true)"};
    PandArg<bool> concurrent_gc_enabled_{"concurrent-gc-enabled", true, R"(whether concurrent GC is enabled. Default: true)"};
    PandArg<bool> snapshot_serialize_enabled_{"snapshot-serialize-enabled", false, R"(whether snapshot serialize is enabled. Default: false)"};
    PandArg<bool> snapshot_deserialize_enabled_{"snapshot-deserialize-enabled", true, R"(whether snapshot deserialize is enabled. Default: true)"};
    PandArg<std::string> snapshot_file_{"snapshot-file", R"(/system/etc/snapshot)", R"(snapshot file. Default: "/system/etc/snapshot")"};
    PandArg<std::string> framework_abc_file_{"framework-abc-file", R"(strip.native.min.abc)", R"(snapshot file. Default: "strip.native.min.abc")"};
    PandArg<std::string> boot_an_location_{"boot-an-location", R"(/data/service/el1/public/for-all-app/framework_ark_cache)", R"(default path to .an files for boot panda files, try to load ARK .an file from this dir if not empty when enable-an. Default: "/data/service/el1/public/for-all-app/framework_ark_cache")"};
    PandArg<bool> enable_an_force_{"force", false, R"(Crash if there is no .an file for both location based on .abc file and boot-an-location. Default: false)"};
    PandArgCompound enable_an_{"enable-an", R"(Try to load ARK .an file for boot panda files from boot-an-location or base on abc file location. Default: "false")", {&enable_an_force_}};
    PandArg<bool> verify_call_stack_{"verify-call-stack", false, R"(Verify call stack before using of the StackWalker. Default: false)"};
    PandArg<bool> safepoint_backtrace_{"safepoint-backtrace", false, R"(Print backtrace each time a thread gets suspended. Default: false)"};
    PandArg<uint64_t> aot_string_gc_roots_limit_{"aot-string-gc-roots-limit", AOT_STRING_GC_ROOTS_LIMIT_DEFAULT, R"(Maximum amount of AOT string PLT-slots registered as GC roots. Default: 1000)"};
    PandArg<uint32_t> resolve_string_aot_threshold_{"resolve-string-aot-threshold", RESOLVE_STRING_AOT_THRESHOLD_DEFAULT, R"(Minimum amount of ResolveStringAot calls before storing string pointer into PLT-slot. Default: 1)"};
    PandArg<std::string> icu_data_path_{"icu-data-path", R"(default)", R"(Path to generated icu data file. Default: "default")"};
    PandArg<bool> ark_aot_{"ark-aot", false, R"(check if runtime start by ark_aot. Default: false)"};
    PandArg<arg_list_t> intrinsics_blacklist_{"intrinsics-blacklist", {}, R"(List of methods for which intrinsics should not be linked. Default: [])", ","};
    PandArg<bool> verify_entrypoints_{"verify-entrypoints", false, R"(Verify compiler entrypoints. Default: false)"};
    PandArg<uint32_t> ignore_daemon_memory_leaks_threshold_{"ignore-daemon-memory-leaks-threshold", IGNORE_DAEMON_MEMORY_LEAKS_THRESHOLD_DEFAULT, R"(Ignore daemon memory leaks during runtime destruction with the specified threshold. Default: 0)"};
    PandArg<std::string> interpreter_type_{"interpreter-type", R"(llvm)", R"(Interpreter implementation type. Possible values: ["cpp", "irtoc", "llvm"]. Default: "llvm")"};
    PandArg<std::string> abc_layout_profile_location_{"abc-layout-profile-location", R"(/data/profile/)", R"(Specify the location of abc layout profile. Default: "/data/profile/")"};
    PandArg<uint32_t> intrusive_test_{"intrusive-test", INTRUSIVE_TEST_DEFAULT, R"(Numerical identifier of an intrusive test. Default: 0)"};
    PandArg<std::string> profile_output_{"profile-output", R"(profile.ap)", R"(Specify the location the collected profile information. Default: "profile.ap")"};
    PandArg<uint32_t> call_profiling_table_size_{"call-profiling-table-size", CALL_PROFILING_TABLE_SIZE_DEFAULT, R"(Size of call profiling table size. Default: 1000)"};
    PandArg<uint32_t> coroutine_stack_size_pages_{"coroutine-stack-size-pages", COROUTINE_STACK_SIZE_PAGES_DEFAULT, R"(defines stack size for stackful coroutines (in number of pages). Default: 64)"};
    PandArg<uint64_t> coroutines_stack_mem_limit_;
    PandArg<uint64_t> coroutines_user_limit_{"coroutines-user-limit", COROUTINES_USER_LIMIT_DEFAULT, R"(The amount of allowed user coroutines (0 to auto). Default: 0)"};
    PandArg<bool> use_coroutine_pool_{"use-coroutine-pool", true, R"(caches coroutine and coroutine context instances in a pool to speedup creation/destruction. Default: true)"};
    PandArg<std::string> workers_type_{"workers-type", R"(taskmanager)", R"(Set type of additional VM workers. VM uses these workers to speed up internal algorithms (JIT, GC, etc.). Possible values: ["threadpool", "taskmanager"]. Default: "taskmanager")"};
    PandArg<uint32_t> taskmanager_workers_count_;
    PandArg<std::string> task_stats_type_{"task-stats-type", R"(no-task-stats)", R"(Set type of task stats that will collect task manager metrics, if use set `no-task-stats` there will be no stats collection. Possible values: ["no-task-stats", "light-task-stats"]. Default: "no-task-stats")"};
    PandArg<bool> load_in_boot_{"load-in-boot", false, R"(Load entrypoint panda file in boot-panda-files. Default: false)"};
    PandArg<bool> use_string_caches_{"use-string-caches", true, R"(Whether to create cache for strings created from integer/floating point numbers. Default: true)"};
    PandArg<bool> use_all_strings_{"use-all-strings", true, R"(Whether to create strings with LineString/SlicedString/TreeString or only LineString. Default: true)"};
    PandArg<bool> code_coverage_enabled_{"code-coverage-enabled", false, R"(whether ArkTS 1.2 code coverage is enabled. Default: false)"};
    PandArg<std::string> code_coverage_output_{"code-coverage-output", R"()", R"(Specify the location the collected code coverage information. Default: "")"};
    PandArg<bool> use_boot_class_filter_{"use-boot-class-filter", true, R"(Whether to use boot class bloom filter to speedup app class lookup. Default: true)"};
    PandArg<bool> enable_class_linker_trace_{"enable-class-linker-trace", false, R"(Enable class linker trace. Default: false)"};
    PandArg<uint32_t> xgc_min_trigger_threshold_{"xgc-min-trigger-threshold", XGC_MIN_TRIGGER_THRESHOLD_DEFAULT, R"(Initial count of live shared references count for XGC triggering. Default: 20480)"};
    PandArg<uint32_t> xgc_trigger_percent_threshold_{"xgc-trigger-percent-threshold", XGC_TRIGGER_PERCENT_THRESHOLD_DEFAULT, R"(Percent for XGC threshold increasing. Default: 20)"};
    PandArg<std::string> ets_xgc_trigger_type_{"ets.xgc-trigger-type", R"(default)", R"(Set XGC trigger policy. Only for ets. Possible values: ["default", "force", "never"]. Default: "default")"};
    PandArg<std::string> xgc_trigger_type_{"xgc-trigger-type", R"(default)", R"(Set XGC trigger policy. Possible values: ["default", "force", "never"]. Default: "default")"};
    PandArg<bool> enable_xgc_verifier_{"enable-xgc-verifier", false, R"(Enable switch for shared reference storage verification. Default: false)"};
    PandArg<bool> ets_taskpool_support_interop_{"ets.taskpool-support-interop", false, R"(taskpool support interop or not, only valid when taskpool-mode is eaworker. Only for ets. Default: false)"};
    PandArg<bool> taskpool_support_interop_{"taskpool-support-interop", false, R"(taskpool support interop or not, only valid when taskpool-mode is eaworker. Default: false)"};
    PandArg<bool> ets_fail_on_heap_verification_{"ets.fail-on-heap-verification", false, R"(if enabled then fail execution if heap verifier found heap corruption. Only for ets. Default: false)"};
    PandArg<bool> fail_on_heap_verification_{"fail-on-heap-verification", false, R"(if enabled then fail execution if heap verifier found heap corruption. Default: false)"};
    PandArg<bool> ets_pre_gc_heap_verify_enabled_{"ets.pre-gc-heap-verify-enabled", false, R"(whether verify heap before GC. Only for ets. Default: false)"};
    PandArg<bool> pre_gc_heap_verify_enabled_{"pre-gc-heap-verify-enabled", false, R"(whether verify heap before GC. Default: false)"};
    PandArg<bool> ets_into_gc_heap_verify_enabled_{"ets.into-gc-heap-verify-enabled", false, R"(whether verify heap during GC. Only for ets. Default: false)"};
    PandArg<bool> into_gc_heap_verify_enabled_{"into-gc-heap-verify-enabled", false, R"(whether verify heap during GC. Default: false)"};
    PandArg<bool> ets_post_gc_heap_verify_enabled_{"ets.post-gc-heap-verify-enabled", false, R"(whether verify heap after GC. Only for ets. Default: false)"};
    PandArg<bool> post_gc_heap_verify_enabled_{"post-gc-heap-verify-enabled", false, R"(whether verify heap after GC. Default: false)"};
    PandArg<bool> ets_enable_paralled_young_gc_{"ets.enable-paralled-young-gc", true, R"(enable-paralled-young-gc. Only for ets. Default: true)"};
    PandArg<bool> enable_paralled_young_gc_{"enable-paralled-young-gc", true, R"(enable-paralled-young-gc. Default: true)"};
    PandArg<std::string> ets_coroutine_impl_{"ets.coroutine-impl", R"(stackful)", R"(chooses coroutine implementation (either OS thread based emulation or full-featured fiber like). Only for ets. Possible values: ["threaded", "stackful"]. Default: "stackful")"};
    PandArg<std::string> coroutine_impl_{"coroutine-impl", R"(stackful)", R"(chooses coroutine implementation (either OS thread based emulation or full-featured fiber like). Possible values: ["threaded", "stackful"]. Default: "stackful")"};
    PandArg<uint32_t> ets_coroutine_workers_count_{"ets.coroutine-workers-count", ETS_COROUTINE_WORKERS_COUNT_DEFAULT, R"(Number of worker threads for the NxM coroutine scheme (use 0 for auto). Only for ets. Default: 0)"};
    PandArg<uint32_t> coroutine_workers_count_{"coroutine-workers-count", COROUTINE_WORKERS_COUNT_DEFAULT, R"(Number of worker threads for the NxM coroutine scheme (use 0 for auto). Default: 0)"};
    PandArg<uint32_t> ets_coroutine_e_workers_limit_{"ets.coroutine-e-workers-limit", ETS_COROUTINE_E_WORKERS_LIMIT_DEFAULT, R"(Limit on the number of exclusive coroutines workers. Only for ets. Default: 64)"};
    PandArg<uint32_t> coroutine_e_workers_limit_{"coroutine-e-workers-limit", COROUTINE_E_WORKERS_LIMIT_DEFAULT, R"(Limit on the number of exclusive coroutines workers. Default: 64)"};
    PandArg<bool> coroutine_enable_features_ani_drain_queue_{"ani-drain-queue", false, R"(Drain the coroutine queue after native interface calls. Default: false)"};
    PandArg<bool> coroutine_enable_features_migration_{"migration", false, R"(migration. Default: false)"};
    PandArg<bool> coroutine_enable_features_migrate_awakened_{"migrate-awakened", false, R"(migrate awakened coroutines. Default: false)"};
    PandArg<bool> coroutine_enable_features_enable_external_timer_{"enable-external-timer", false, R"(Enable/disable external timer implementation. Default: false)"};
    PandArgCompound coroutine_enable_features_{"coroutine-enable-features", R"(Specify a list of experimental features. Default: "false")", {&coroutine_enable_features_ani_drain_queue_, &coroutine_enable_features_migration_, &coroutine_enable_features_migrate_awakened_, &coroutine_enable_features_enable_external_timer_}};
    PandArg<bool> ets_coroutine_dump_stats_{"ets.coroutine-dump-stats", false, R"(Collect coroutine stats and dump it at the end of the program. Only for ets. Default: false)"};
    PandArg<bool> coroutine_dump_stats_{"coroutine-dump-stats", false, R"(Collect coroutine stats and dump it at the end of the program. Default: false)"};
    PandArg<std::string> ets_taskpool_mode_{"ets.taskpool-mode", R"(eaworker)", R"(taskpool using eaworker or launch as execution engine. Only for ets. Possible values: ["eaworker", "launch"]. Default: "eaworker")"};
    PandArg<std::string> taskpool_mode_{"taskpool-mode", R"(eaworker)", R"(taskpool using eaworker or launch as execution engine. Possible values: ["eaworker", "launch"]. Default: "eaworker")"};
    PandArg<arg_list_t> ets_native_library_path_{"ets.native-library-path", {}, R"(Pathes to find native libraries. Only for ets. Default: [])", ":"};
    PandArg<arg_list_t> native_library_path_{"native-library-path", {}, R"(Pathes to find native libraries. Default: [])", ":"};
    PandArg<bool> list_unhandled_on_exit_promises_{"promises", true, R"(promises. Default: true)"};
    PandArg<bool> list_unhandled_on_exit_jobs_{"jobs", false, R"(jobs. Default: false)"};
    PandArgCompound list_unhandled_on_exit_{"list-unhandled-on-exit", R"(Collect rejected promises/jobs and throw if there is at least one unhandled on program exit. Default: "false")", {&list_unhandled_on_exit_promises_, &list_unhandled_on_exit_jobs_}};
};
// NOLINTEND(readability-identifier-naming,readability-magic-numbers)
}  // namespace ark

#endif  // PANDA_RUNTIME_OPTIONS_GEN_H
