/********************************************************************************
** Form generated from reading UI file 'settings_dialog.ui'
**
** Created by: Qt User Interface Compiler version 6.11.0
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_SETTINGS_DIALOG_H
#define UI_SETTINGS_DIALOG_H

#include <QtCore/QVariant>
#include <QtGui/QIcon>
#include <QtWidgets/QAbstractButton>
#include <QtWidgets/QApplication>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QDateTimeEdit>
#include <QtWidgets/QDialog>
#include <QtWidgets/QDialogButtonBox>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QFrame>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QGroupBox>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QLabel>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QListWidget>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QRadioButton>
#include <QtWidgets/QScrollArea>
#include <QtWidgets/QSlider>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QTabWidget>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>

QT_BEGIN_NAMESPACE

class Ui_settings_dialog
{
public:
    QVBoxLayout *settings_dialog_layout;
    QScrollArea *scrollArea;
    QTabWidget *tab_widget_settings;
    QWidget *coreTab;
    QVBoxLayout *coreTabLayout;
    QHBoxLayout *coreTabItemLayout;
    QVBoxLayout *coreTabLeftLayout;
    QGroupBox *gb_ppu;
    QVBoxLayout *ppu_layout;
    QRadioButton *ppu__static;
    QRadioButton *ppu_llvm;
    QGroupBox *gb_spu;
    QVBoxLayout *spu_layout;
    QRadioButton *spu__static;
    QRadioButton *spu_dynamic;
    QRadioButton *spu_asmjit;
    QRadioButton *spu_llvm;
    QSpacerItem *coreTabLeftLayoutSpacer;
    QVBoxLayout *coreTabMiddleLayout;
    QGroupBox *gb_xfloat_accuracy;
    QVBoxLayout *gb_xfloat_accuracy_layout;
    QComboBox *xfloatAccuracy;
    QGroupBox *gb_spuBlockSize;
    QVBoxLayout *gb_spuBlockSize_layout;
    QComboBox *spuBlockSize;
    QGroupBox *gb_max_preempt_count;
    QVBoxLayout *gb_max_preempt_layout;
    QSlider *maxPreemptCount;
    QHBoxLayout *maxPreemptLayout;
    QLabel *preemptText;
    QPushButton *preemptReset;
    QSpacerItem *coreTabMiddleLayoutSpacer;
    QVBoxLayout *coreTabRightLayout;
    QGroupBox *gb_spu_threads;
    QVBoxLayout *gb_spu_threads_layout;
    QComboBox *preferredSPUThreads;
    QGroupBox *gb_threadsched;
    QVBoxLayout *gb_threadsched_layout;
    QComboBox *threadsched;
    QSpacerItem *coreTabRightLayoutSpacer;
    QSpacerItem *coreTabSpacer;
    QGroupBox *gb_description_cpu;
    QVBoxLayout *gb_description_cpu_layout;
    QLabel *description_cpu;
    QWidget *gpuTab;
    QVBoxLayout *gpuTab_layout;
    QHBoxLayout *gpuTabLayout;
    QVBoxLayout *gpuTabLayoutLeft;
    QGroupBox *gb_renderer;
    QVBoxLayout *gb_renderer_layout;
    QComboBox *renderBox;
    QGroupBox *gb_graphicsAdapter;
    QVBoxLayout *gb_graphicsAdapter_layout;
    QComboBox *graphicsAdapterBox;
    QWidget *widget_gpu_top;
    QHBoxLayout *widget_gpu_top_layout;
    QGroupBox *gb_aspectRatio;
    QVBoxLayout *gb_aspectRatio_layout;
    QComboBox *aspectBox;
    QGroupBox *gb_frameLimit;
    QVBoxLayout *gb_frameLimit_layout;
    QComboBox *frameLimitBox;
    QWidget *widget_gpu_bottom;
    QHBoxLayout *widget_gpu_bottom_layout;
    QGroupBox *gb_anisotropicFilter;
    QVBoxLayout *gb_anisotropicFilter_layout;
    QComboBox *anisotropicFilterOverride;
    QGroupBox *gb_antiAliasing;
    QVBoxLayout *gb_antiAliasing_layout;
    QComboBox *antiAliasing;
    QWidget *widget_gpu_3;
    QHBoxLayout *widget_gpu_3_layout;
    QGroupBox *gbZCULL;
    QVBoxLayout *gbZCULL_layout;
    QComboBox *zcullPrecisionMode;
    QGroupBox *gbShaderPrecision;
    QVBoxLayout *gbShaderPrecision_layout;
    QComboBox *shaderPrecision;
    QWidget *widget_gpu_4;
    QHBoxLayout *widget_gpu_4_layout;
    QGroupBox *gbVsync;
    QVBoxLayout *gbVsync_layout;
    QComboBox *vsyncMode;
    QGroupBox *gb_stereo;
    QVBoxLayout *gb_stereo_layout;
    QCheckBox *stereoRenderEnabled;
    QComboBox *stereoRenderMode;
    QGroupBox *gb_screen_size;
    QVBoxLayout *layout_gb_screen_size;
    QSpinBox *sb_screen_size;
    QSpacerItem *gpu_tab_layout_right_spacer;
    QVBoxLayout *gpuTabLayoutMiddle;
    QGroupBox *gb_default_resolution;
    QVBoxLayout *gb_default_resolution_layout;
    QComboBox *resBox;
    QVBoxLayout *layout_resolution_scale;
    QGroupBox *gb_resolutionScale;
    QVBoxLayout *gb_resolutionScale_layout;
    QWidget *resolutionScaleLayoutTop;
    QHBoxLayout *horizontalLayout_23;
    QLabel *resolutionScaleMin;
    QSlider *resolutionScale;
    QLabel *resolutionScaleMax;
    QHBoxLayout *resolutionScaleLayoutBottom;
    QLabel *resolutionScaleVal;
    QPushButton *resolutionScaleReset;
    QGroupBox *gb_minimumScalableDimension;
    QVBoxLayout *gb_minimumScalableDimension_layout;
    QHBoxLayout *minimumScalableDimensionLayoutTop;
    QLabel *minimumScalableDimensionMin;
    QSlider *minimumScalableDimension;
    QLabel *minimumScalableDimensionMax;
    QHBoxLayout *minimumScalableDimensionLayoutBottom;
    QLabel *minimumScalableDimensionVal;
    QPushButton *minimumScalableDimensionReset;
    QGroupBox *gb_outputScaling;
    QVBoxLayout *gb_Upscaling_layout;
    QComboBox *outputScalingMode;
    QFrame *line;
    QWidget *fsrSharpeningStrengthWidget;
    QVBoxLayout *fsrSharpeningWidgetLayout;
    QLabel *fsrSharpeningStrengthLabel;
    QHBoxLayout *fsrSharpeningLayoutTop;
    QLabel *minSharpeningVal;
    QSlider *fsrSharpeningStrength;
    QLabel *maxSharpeningVal;
    QHBoxLayout *fsrSharpeningLayoutBottom;
    QLabel *fsrSharpeningStrengthVal;
    QPushButton *fsrSharpeningStrengthReset;
    QSpacerItem *gpu_tab_layout_middle_spacer;
    QVBoxLayout *gpuTabLayoutRight;
    QGroupBox *gb_shader_mode;
    QVBoxLayout *verticalLayout;
    QRadioButton *rb_legacy_recompiler;
    QRadioButton *rb_async_recompiler;
    QRadioButton *rb_async_with_shader_interpreter;
    QRadioButton *rb_shader_interpreter_only;
    QGroupBox *gb_additional_settings;
    QVBoxLayout *gb_additional_settings_layout;
    QCheckBox *dumpColor;
    QCheckBox *strictModeRendering;
    QCheckBox *stretchToDisplayArea;
    QCheckBox *multithreadedRSX;
    QCheckBox *asyncTextureStreaming;
    QSpacerItem *additional_settings_spacer;
    QSpacerItem *gpuTabSpacer;
    QGroupBox *gb_description_gpu;
    QHBoxLayout *gb_description_gpu_layout;
    QLabel *description_gpu;
    QWidget *audioTab;
    QVBoxLayout *audioTab_layout;
    QHBoxLayout *audioTabLayoutTop;
    QVBoxLayout *audioTabLayoutTopLeft;
    QGroupBox *gb_audio_out;
    QVBoxLayout *gb_audio_out_layout;
    QComboBox *audioOutBox;
    QGroupBox *gb_audio_format;
    QVBoxLayout *gb_audio_format_layout;
    QComboBox *combo_audio_format;
    QListWidget *list_audio_formats;
    QGroupBox *gb_audio_settings;
    QVBoxLayout *gb_audio_settings_layout;
    QCheckBox *convert;
    QCheckBox *audioDump;
    QSpacerItem *spacer_audio_settings;
    QSpacerItem *verticalSpacerAudioLeft;
    QVBoxLayout *audioTabLayoutTopMiddle;
    QGroupBox *gb_audio_device;
    QVBoxLayout *gb_audio_device_layout;
    QComboBox *audioDeviceBox;
    QGroupBox *gb_audio_channel_layout;
    QVBoxLayout *gb_audio_channel_layout_layout;
    QComboBox *combo_audio_channel_layout;
    QGroupBox *gb_audio_provider;
    QVBoxLayout *gb_audio_provider_layout;
    QComboBox *audioProviderBox;
    QGroupBox *gb_audio_avport;
    QVBoxLayout *gb_audio_avport_layout;
    QComboBox *audioAvportBox;
    QGroupBox *gb_music_handler;
    QVBoxLayout *gb_music_handler_layout;
    QComboBox *musicHandlerBox;
    QGroupBox *gb_audio_volume;
    QVBoxLayout *gb_audio_volume_layout;
    QWidget *master_volume;
    QVBoxLayout *layout_master_volume;
    QLabel *masterVolumeLabel;
    QSlider *masterVolume;
    QSpacerItem *spacer_audio_volume;
    QVBoxLayout *audioTabLayoutTopRight;
    QGroupBox *gb_audio_buffering;
    QVBoxLayout *gb_audio_buffering_layout;
    QCheckBox *enableBuffering;
    QWidget *audio_buffer_duration;
    QVBoxLayout *layout_audio_buffer_duration;
    QLabel *audioBufferDurationLabel;
    QSlider *audioBufferDuration;
    QCheckBox *enableTimeStretching;
    QWidget *time_stretching_threshold;
    QVBoxLayout *layout_time_stretching_threshold;
    QLabel *timeStretchingThresholdLabel;
    QSlider *timeStretchingThreshold;
    QSpacerItem *verticalSpacerAudioRight;
    QGroupBox *gb_microphone_settings;
    QVBoxLayout *gb_microphone_settings_layout;
    QHBoxLayout *microphoneLayoutTop;
    QLabel *microphoneLabel;
    QComboBox *microphoneBox;
    QSpacerItem *microphoneSpacer;
    QHBoxLayout *microphoneLayoutBottom;
    QVBoxLayout *microphoneLayoutLabel1and3;
    QLabel *microphone1Label;
    QLabel *microphone3Label;
    QVBoxLayout *microphoneLayoutBox1and3;
    QComboBox *microphone1Box;
    QComboBox *microphone3Box;
    QVBoxLayout *microphoneLayoutLabel2and4;
    QLabel *microphone2Label;
    QLabel *microphone4Label;
    QVBoxLayout *microphoneLayoutBox2and4;
    QComboBox *microphone2Box;
    QComboBox *microphone4Box;
    QSpacerItem *audioTabSpacer;
    QGroupBox *gb_description_audio;
    QVBoxLayout *gb_description_audio_layout;
    QLabel *description_audio;
    QWidget *inputTab;
    QVBoxLayout *inputTab_layout;
    QGridLayout *ioGridLayout;
    QGroupBox *gb_ghltar_emulated;
    QVBoxLayout *gb_ghltar_emulated_layout;
    QComboBox *ghltarBox;
    QGroupBox *gb_move_handler;
    QVBoxLayout *gb_move_handler_layout;
    QComboBox *moveBox;
    QGroupBox *gb_turntable_emulated;
    QVBoxLayout *gb_turntable_emulated_layout;
    QComboBox *turntableBox;
    QGroupBox *gb_mouse_handler;
    QVBoxLayout *gb_mouse_handler_layout;
    QComboBox *mouseHandlerBox;
    QGroupBox *gb_buzz_emulated;
    QVBoxLayout *gb_buzz_emulated_layout;
    QComboBox *buzzBox;
    QGroupBox *gb_keyboard_handler;
    QVBoxLayout *gb_keyboard_handler_layout;
    QComboBox *keyboardHandlerBox;
    QGroupBox *gb_pad_mode;
    QVBoxLayout *gb_pad_mode_layout;
    QComboBox *padModeBox;
    QGroupBox *gb_camera_type;
    QVBoxLayout *gb_camera_type_layout;
    QComboBox *cameraTypeBox;
    QGroupBox *gb_camera_flip;
    QVBoxLayout *gb_camera_flip_layout;
    QComboBox *cameraFlipBox;
    QGroupBox *gb_camera_id;
    QVBoxLayout *camera_id_layout;
    QComboBox *cameraIdBox;
    QGroupBox *gb_camera_setting;
    QVBoxLayout *gb_camera_setting_layout;
    QComboBox *cameraBox;
    QGroupBox *gb_midi_1;
    QVBoxLayout *midLayout1;
    QHBoxLayout *midiHLayout1;
    QComboBox *midiTypeBox1;
    QComboBox *midiDeviceBox1;
    QGroupBox *gb_midi_3;
    QVBoxLayout *midLayout3;
    QHBoxLayout *midiHLayout3;
    QComboBox *midiTypeBox3;
    QComboBox *midiDeviceBox3;
    QGroupBox *gb_midi_2;
    QVBoxLayout *midLayout2;
    QHBoxLayout *midiHLayout2;
    QComboBox *midiTypeBox2;
    QComboBox *midiDeviceBox2;
    QGroupBox *gb_additional_io_settings;
    QVBoxLayout *layout_gb_additional_io_settings;
    QCheckBox *backgroundInputBox;
    QCheckBox *padConnectionBox;
    QCheckBox *showMoveCursorBox;
    QCheckBox *lockOverlayInputToPlayerOne;
    QCheckBox *loadSdlMappings;
    QSpacerItem *verticalSpacerIoAdditionalSettings;
    QSpacerItem *inputTabSpacer;
    QGroupBox *gb_description_io;
    QVBoxLayout *gb_description_io_layout;
    QLabel *description_io;
    QWidget *systemTab;
    QVBoxLayout *systemTab_layout;
    QHBoxLayout *systemTabHorizontalLayout;
    QVBoxLayout *systemTabLeftLayout;
    QGroupBox *gb_sysLang;
    QVBoxLayout *gb_sysLang_layout;
    QComboBox *sysLangBox;
    QGroupBox *gb_console_region;
    QVBoxLayout *gb_console_region_layout;
    QComboBox *console_region;
    QGroupBox *gb_enterButtonAssignment;
    QVBoxLayout *gb_enterButtonAssignment_layout;
    QRadioButton *enterButtonAssignCircle;
    QRadioButton *enterButtonAssignCross;
    QGroupBox *gb_DiskCacheClearing;
    QVBoxLayout *gb_DiskCacheClearing_layout;
    QCheckBox *enableCacheClearing;
    QLabel *maximumCacheSizeLabel;
    QSlider *maximumCacheSize;
    QSpacerItem *systemTabLeftVerticalSpacer;
    QVBoxLayout *systemTabMiddleLayout;
    QGroupBox *gb_keyboardType;
    QVBoxLayout *verticalLayout_keyboardType;
    QComboBox *keyboardType;
    QGroupBox *gb_dateFormat;
    QVBoxLayout *verticalLayout_dateFormat;
    QComboBox *dateFormat;
    QGroupBox *gb_timeFormat;
    QVBoxLayout *verticalLayout_timeFormat;
    QComboBox *timeFormat;
    QGroupBox *gb_console_time;
    QVBoxLayout *verticalLayout_2;
    QHBoxLayout *horizontalLayout;
    QDateTimeEdit *console_time_edit;
    QPushButton *console_time_reset;
    QSpacerItem *systemTabMiddleVerticalSpacer;
    QVBoxLayout *systemTabRightLayout;
    QGroupBox *gb_homebrew;
    QVBoxLayout *gb_homebrew_layout;
    QCheckBox *enableHostRoot;
    QCheckBox *emptyHdd0Tmp;
    QSpacerItem *systemTabRightVerticalSpacer;
    QSpacerItem *systemTabSpacer;
    QGroupBox *gb_description_system;
    QHBoxLayout *gb_description_system_layout;
    QLabel *description_system;
    QWidget *networkTab;
    QVBoxLayout *networkTab_layout;
    QHBoxLayout *networkTabLayout;
    QGroupBox *gb_network_status;
    QVBoxLayout *gb_network_status_layout;
    QGroupBox *gb_netStatusBox;
    QVBoxLayout *gb_netStatusBox_layout;
    QComboBox *netStatusBox;
    QGroupBox *gb_edit_dns;
    QVBoxLayout *gb_edit_dns_layout;
    QLineEdit *edit_dns;
    QGroupBox *gb_edit_swaps;
    QVBoxLayout *gb_edit_swaps_layout;
    QLineEdit *edit_swaps;
    QGroupBox *gb_edit_bind;
    QVBoxLayout *gb_edit_bind_layout;
    QLineEdit *edit_bind;
    QCheckBox *enable_upnp;
    QSpacerItem *networkTabSpacerLeft;
    QGroupBox *gb_psn_config;
    QVBoxLayout *gb_psn_config_layout;
    QGroupBox *gb_psnStatusBox;
    QVBoxLayout *gb_psnStatusBox_layout;
    QComboBox *psnStatusBox;
    QGroupBox *gb_psnCountryBox;
    QVBoxLayout *gb_psnCountryBox_layout;
    QComboBox *psnCountryBox;
    QCheckBox *enable_clans;
    QSpacerItem *networkTabSpacerRight;
    QSpacerItem *networkTabSpacer;
    QGroupBox *gb_description_network;
    QVBoxLayout *gb_description_network_layout;
    QLabel *description_network;
    QWidget *advancedTab;
    QVBoxLayout *advancedTab_layout;
    QHBoxLayout *advancedTabLayout;
    QVBoxLayout *advancedTabLayoutLeft;
    QGroupBox *gb_advanced_core;
    QVBoxLayout *gb_advanced_core_layout;
    QCheckBox *accurateRSXAccess;
    QCheckBox *accurateSpuDMA;
    QCheckBox *antiCheatSavestates;
    QCheckBox *debugConsoleMode;
    QCheckBox *mfcDelayCommand;
    QCheckBox *disableSpinOptimization;
    QCheckBox *enableSpuEventsBusyLoop;
    QCheckBox *spuLoopDetection;
    QCheckBox *llvmPrecompilation;
    QCheckBox *silenceAllLogs;
    QCheckBox *compatibleSavestates;
    QGroupBox *gb_sleep_timers_accuracy;
    QVBoxLayout *gb_sleep_timers_accuracy_layout;
    QComboBox *sleepTimersAccuracy;
    QGroupBox *gb_max_spurs_threads;
    QVBoxLayout *gb_max_spurs_threads_layout;
    QComboBox *maxSPURSThreads;
    QGroupBox *gb_clockScale;
    QVBoxLayout *gb_clockScale_layout;
    QSlider *clockScale;
    QHBoxLayout *clockScaleLayout;
    QLabel *clockScaleText;
    QPushButton *clockScaleReset;
    QSpacerItem *advancedTabSpacerLeft;
    QVBoxLayout *advancedTabLayoutMiddle;
    QGroupBox *gb_libs;
    QVBoxLayout *gb_libs_layout;
    QListWidget *hleList;
    QListWidget *lleList;
    QHBoxLayout *gb_lleLibs_layout;
    QLineEdit *searchBox;
    QPushButton *resetLleList;
    QVBoxLayout *advancedTabLayoutRight;
    QGroupBox *gb_advanced_gpu;
    QVBoxLayout *gb_advanced_gpu_layout;
    QCheckBox *allowHostGPULabels;
    QCheckBox *disableMslFastMath;
    QCheckBox *disableVertexCache;
    QCheckBox *forceHwMSAAResolve;
    QCheckBox *handleTiledMemory;
    QCheckBox *readDepth;
    QCheckBox *readColor;
    QCheckBox *useReBAR;
    QCheckBox *dumpDepth;
    QGroupBox *gb_rsx_fifo_accuracy;
    QVBoxLayout *gb_rsx_fifo_accuracy_layout;
    QComboBox *FIFOAccuracy;
    QGroupBox *gb_exclusiveFullscreen;
    QVBoxLayout *gb_exclusiveFullscreen_layout;
    QComboBox *exclusiveFullscreenMode;
    QGroupBox *gb_wakeupDelay;
    QVBoxLayout *gb_wakeupDelay_layout;
    QSlider *wakeupDelay;
    QHBoxLayout *wakeupDelayLayout;
    QLabel *wakeupText;
    QPushButton *wakeupReset;
    QGroupBox *gb_vblank;
    QVBoxLayout *gb_vblank_layout;
    QSlider *vblank;
    QHBoxLayout *vBlankLayout;
    QLabel *vblankText;
    QPushButton *vblankReset;
    QCheckBox *vblankNTSCFixup;
    QSpacerItem *advancedTabSpacerRight;
    QSpacerItem *advancedTabSpacer;
    QGroupBox *gb_description_advanced;
    QVBoxLayout *gb_description_advanced_layout;
    QLabel *description_advanced;
    QWidget *emulatorTab;
    QVBoxLayout *emulatorTab_layout;
    QHBoxLayout *emulatorTabLayout;
    QVBoxLayout *emulatorTabLayoutLeft;
    QGroupBox *gb_emu_settings;
    QVBoxLayout *gb_emu_settings_layout;
    QCheckBox *enableGamemode;
    QCheckBox *exitOnStop;
    QCheckBox *pausedSavestates;
    QCheckBox *pauseDuringHomeMenu;
    QCheckBox *pauseOnFocusLoss;
    QCheckBox *preventDisplaySleep;
    QCheckBox *startGameFullscreen;
    QCheckBox *useNativeInterface;
    QGroupBox *gb_overlay_settings;
    QVBoxLayout *gb_overlay_settings_layout;
    QCheckBox *playMusicDuringBoot;
    QCheckBox *recordWithOverlays;
    QCheckBox *showAnalogLimiterToggleHint;
    QCheckBox *showAutosaveAutoloadHint;
    QCheckBox *showCaptureHints;
    QCheckBox *showFatalErrorHints;
    QCheckBox *showMouseAndKeyboardToggleHint;
    QCheckBox *showRpcnPopups;
    QCheckBox *showPressureIntensityToggleHint;
    QCheckBox *showPPUCompilationHint;
    QCheckBox *showShaderCompilationHint;
    QCheckBox *showTrophyPopups;
    QSpacerItem *emulatorTabSpacerLeft;
    QGroupBox *gb_max_llvm;
    QVBoxLayout *gb_max_llvm_layout;
    QComboBox *maxLLVMThreads;
    QGroupBox *gb_shader_compiler_threads;
    QVBoxLayout *gb_shader_compiler_threads_layout;
    QComboBox *shaderCompilerThreads;
    QVBoxLayout *emulatorTabLayoutMiddle;
    QGroupBox *gb_viewport;
    QVBoxLayout *gb_viewport_layout;
    QCheckBox *gs_disableMouse;
    QCheckBox *gs_disableKbHotkeys;
    QCheckBox *gs_showMouseInFullscreen;
    QCheckBox *gs_lockMouseInFullscreen;
    QWidget *gs_hideMouseOnIdle_widget;
    QHBoxLayout *gs_hideMouseOnIdle_layout;
    QCheckBox *gs_hideMouseOnIdle;
    QSpinBox *gs_hideMouseOnIdleTime;
    QWidget *gs_resizeOnBoot_widget;
    QVBoxLayout *gs_resizeOnBoot_layout;
    QCheckBox *gs_resizeOnBoot;
    QCheckBox *gs_resizeOnBootManual;
    QHBoxLayout *gs_resolution_layout;
    QGroupBox *gb_gs_width;
    QVBoxLayout *gb_gs_width_layout;
    QSpinBox *gs_width;
    QGroupBox *gb_gs_height;
    QVBoxLayout *gb_gs_height_layout;
    QSpinBox *gs_height;
    QGroupBox *gb_shader_load;
    QVBoxLayout *gb_shader_load_layout;
    QCheckBox *shaderLoadBgEnabled;
    QLabel *label_shaderLoadBgDarkening;
    QSlider *shaderLoadBgDarkening;
    QLabel *label_shaderLoadBgBlur;
    QSlider *shaderLoadBgBlur;
    QSpacerItem *spacer_shader_load;
    QGroupBox *gb_game_window_title;
    QVBoxLayout *layout_gb_game_window_title;
    QLabel *label_game_window_title_format;
    QHBoxLayout *layout_buttons_game_window_title;
    QPushButton *reset_button_game_window_title_format;
    QPushButton *edit_button_game_window_title_format;
    QVBoxLayout *emulatorTabLayoutRight;
    QGroupBox *gb_performance_overlay;
    QVBoxLayout *gb_performance_overlay_layout;
    QCheckBox *perfOverlayEnabled;
    QCheckBox *perfOverlayFramerateGraphEnabled;
    QCheckBox *perfOverlayFrametimeGraphEnabled;
    QWidget *perf_overlay_detail_level;
    QVBoxLayout *layout_perf_overlay_detail_level;
    QLabel *label_detail_level;
    QComboBox *perfOverlayDetailLevel;
    QWidget *perf_overlay_position;
    QVBoxLayout *layout_perf_overlay_position;
    QLabel *label_position;
    QComboBox *perfOverlayPosition;
    QLabel *label_margin_x;
    QHBoxLayout *layout_margin_x;
    QCheckBox *perfOverlayCenterX;
    QDoubleSpinBox *perfOverlayMarginX;
    QLabel *label_margin_y;
    QHBoxLayout *layout_margin_y;
    QCheckBox *perfOverlayCenterY;
    QDoubleSpinBox *perfOverlayMarginY;
    QCheckBox *perfOverlayUseWindowSpace;
    QWidget *perf_overlay_update_interval;
    QVBoxLayout *layout_perf_overlay_update_interval;
    QLabel *label_update_interval;
    QSlider *perfOverlayUpdateInterval;
    QWidget *perf_overlay_font_size;
    QVBoxLayout *layout_perf_overlay_font_size;
    QLabel *label_font_size;
    QSlider *perfOverlayFontSize;
    QWidget *perf_overlay_opacity;
    QVBoxLayout *layout_perf_overlay_opacity;
    QLabel *label_opacity;
    QSlider *perfOverlayOpacity;
    QWidget *perf_overlay_framerate_datapoints;
    QVBoxLayout *layout_perf_overlay_framerate_datapoints;
    QLabel *label_framerate_datapoints;
    QSlider *slider_framerate_datapoints;
    QWidget *perf_overlay_frametime_datapoints;
    QVBoxLayout *layout_perf_overlay_frametime_datapoints;
    QLabel *label_frametime_datapoints;
    QSlider *slider_frametime_datapoints;
    QSpacerItem *emulatorTabSpacerRight;
    QSpacerItem *emulatorTabSpacer;
    QGroupBox *gb_description_emulator;
    QVBoxLayout *gb_description_emulator_layout;
    QLabel *description_emulator;
    QWidget *guiTab;
    QVBoxLayout *guiTab_layout;
    QHBoxLayout *guiTabLayout;
    QVBoxLayout *guiTabLayoutLeft;
    QGroupBox *gb_stylesheets;
    QVBoxLayout *gb_stylesheets_layout;
    QComboBox *combo_stylesheets;
    QPushButton *pb_apply_stylesheet;
    QGroupBox *gb_colors;
    QVBoxLayout *gb_colors_layout;
    QCheckBox *cb_custom_colors;
    QPushButton *pb_gl_icon_color;
    QPushButton *pb_sd_icon_color;
    QPushButton *pb_tr_icon_color;
    QSpacerItem *guiTabSpacerLeft;
    QVBoxLayout *guiTabLayoutMiddle;
    QGroupBox *gb_log;
    QVBoxLayout *gb_log_layout;
    QWidget *log_limit;
    QVBoxLayout *layout_log_limit;
    QLabel *label_log_limit;
    QSpinBox *spinbox_log_limit;
    QWidget *tty_limit;
    QVBoxLayout *layout_tty_limit;
    QLabel *label_tty_limit;
    QSpinBox *spinbox_tty_limit;
    QGroupBox *gb_gui_pad_input;
    QVBoxLayout *gb_gui_pad_input_layout;
    QCheckBox *cb_pad_navigation;
    QCheckBox *cb_global_pad_navigation;
    QGroupBox *gb_gui_volume;
    QVBoxLayout *gb_gui_volume_layout;
    QWidget *gui_volume;
    QVBoxLayout *layout_gui_volume;
    QLabel *guiVolumeLabel;
    QSlider *guiVolume;
    QSpacerItem *guiTabSpacerMiddle;
    QVBoxLayout *guiTabLayoutRight;
    QGroupBox *gb_gui_options;
    QVBoxLayout *gb_gui_options_layout;
    QCheckBox *cb_show_welcome;
    QCheckBox *cb_show_exit_game;
    QCheckBox *cb_show_pkg_install;
    QCheckBox *cb_show_obsolete_cfg_dialog;
    QCheckBox *cb_show_same_buttons_dialog;
    QCheckBox *cb_show_restart_hint;
    QSpacerItem *guiTabSpacerRight;
    QGroupBox *gb_updates;
    QVBoxLayout *layout_gb_updates;
    QComboBox *combo_updates;
    QGroupBox *gb_discord;
    QVBoxLayout *gb_discord_layout;
    QCheckBox *useRichPresence;
    QLabel *label_discordState;
    QLineEdit *discordState;
    QGroupBox *gb_uuid;
    QVBoxLayout *gb_uuid_layout;
    QLabel *label_uuid;
    QPushButton *pb_uuid;
    QSpacerItem *guiTabSpacer;
    QGroupBox *gb_description_gui;
    QVBoxLayout *gb_description_gui_layout;
    QLabel *description_gui;
    QWidget *debugTab;
    QVBoxLayout *debugTab_layout;
    QHBoxLayout *debugTabLayout;
    QGroupBox *gb_debug_gpu;
    QVBoxLayout *gb_debug_gpu_layout;
    QCheckBox *debugOutput;
    QCheckBox *debugOverlay;
    QCheckBox *disableAsyncHostMM;
    QCheckBox *disableFIFOReordering;
    QCheckBox *disableHardwareTexelRemapping;
    QCheckBox *disableOnDiskShaderCache;
    QCheckBox *disableVideoOutput;
    QCheckBox *disableVulkanMemAllocator;
    QCheckBox *disableHwOcclusionQueries;
    QCheckBox *forceCpuBlitEmulation;
    QCheckBox *gpuTextureScaling;
    QCheckBox *logProg;
    QCheckBox *renderdocCompatibility;
    QCheckBox *strictTextureFlushing;
    QCheckBox *forceHighpZ;
    QSpacerItem *verticalSpacerDebugGPU;
    QGroupBox *gb_debug_core;
    QVBoxLayout *gb_debug_core_layout;
    QCheckBox *alwaysStart;
    QCheckBox *perfReport;
    QCheckBox *hookStFunc;
    QCheckBox *mfcDebug;
    QCheckBox *ppuDebug;
    QCheckBox *setDAZandFTZ;
    QCheckBox *spuDebug;
    QCheckBox *spuProfiler;
    QSpacerItem *verticalSpacerDebugCore;
    QGroupBox *gb_debug_cpu;
    QVBoxLayout *gb_debug_cpu_layout;
    QCheckBox *accurateDFMA;
    QCheckBox *accurateClineStores;
    QCheckBox *accuratePPUFPCC;
    QCheckBox *accuratePPUSAT;
    QCheckBox *accuratePPUNJ;
    QCheckBox *accuratePPUVNAN;
    QCheckBox *ppuNJFixup;
    QCheckBox *PPUVNANfixup;
    QSpacerItem *verticalSpacerDebugCpu;
    QWidget *debug_more_stuff;
    QVBoxLayout *debug_more_stuff_layout;
    QGroupBox *gb_accurate_ppu_128;
    QVBoxLayout *gb_accurate_ppu_128_layout;
    QComboBox *combo_accurate_ppu_128;
    QGroupBox *gb_num_ppu_threads;
    QVBoxLayout *vbl_num_ppu_threads;
    QComboBox *combo_num_ppu_threads;
    QGroupBox *gb_Level_of_Detail;
    QVBoxLayout *gb_Level_of_Detail_Layout;
    QHBoxLayout *TextureLODBiasLayout;
    QDoubleSpinBox *TextureLODBias;
    QPushButton *TextureLODBiasReset;
    QGroupBox *gb_vulkansched;
    QVBoxLayout *gb_vksched_layout;
    QComboBox *vulkansched;
    QGroupBox *gb_log_levels;
    QVBoxLayout *gb_log_levels_layout;
    QPushButton *pb_log_levels;
    QGroupBox *gb_debug_io;
    QVBoxLayout *gb_debug_io_layout;
    QCheckBox *debugOverlayIO;
    QCheckBox *debugOverlayMouse;
    QSpacerItem *verticalSpacer;
    QSpacerItem *verticalSpacerDebugMore;
    QSpacerItem *debugTabSpacer;
    QGroupBox *gb_description_debug;
    QVBoxLayout *gb_description_debug_layout;
    QLabel *description_debug;
    QDialogButtonBox *buttonBox;

    void setupUi(QDialog *settings_dialog)
    {
        if (settings_dialog->objectName().isEmpty())
            settings_dialog->setObjectName("settings_dialog");
        settings_dialog->setWindowModality(Qt::WindowModality::WindowModal);
        settings_dialog->resize(856, 688);
        QSizePolicy sizePolicy(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Preferred);
        sizePolicy.setHorizontalStretch(0);
        sizePolicy.setVerticalStretch(0);
        sizePolicy.setHeightForWidth(settings_dialog->sizePolicy().hasHeightForWidth());
        settings_dialog->setSizePolicy(sizePolicy);
        QIcon icon;
        icon.addFile(QString::fromUtf8(":/rpcs3.ico"), QSize(), QIcon::Mode::Normal, QIcon::State::Off);
        settings_dialog->setWindowIcon(icon);
        settings_dialog_layout = new QVBoxLayout(settings_dialog);
        settings_dialog_layout->setObjectName("settings_dialog_layout");
        scrollArea = new QScrollArea(settings_dialog);
        scrollArea->setObjectName("scrollArea");
        scrollArea->setFrameShape(QFrame::Shape::NoFrame);
        scrollArea->setWidgetResizable(true);
        tab_widget_settings = new QTabWidget();
        tab_widget_settings->setObjectName("tab_widget_settings");
        tab_widget_settings->setEnabled(true);
        tab_widget_settings->setGeometry(QRect(0, 0, 821, 716));
        sizePolicy.setHeightForWidth(tab_widget_settings->sizePolicy().hasHeightForWidth());
        tab_widget_settings->setSizePolicy(sizePolicy);
        coreTab = new QWidget();
        coreTab->setObjectName("coreTab");
        coreTabLayout = new QVBoxLayout(coreTab);
        coreTabLayout->setObjectName("coreTabLayout");
        coreTabItemLayout = new QHBoxLayout();
        coreTabItemLayout->setObjectName("coreTabItemLayout");
        coreTabLeftLayout = new QVBoxLayout();
        coreTabLeftLayout->setObjectName("coreTabLeftLayout");
        gb_ppu = new QGroupBox(coreTab);
        gb_ppu->setObjectName("gb_ppu");
        ppu_layout = new QVBoxLayout(gb_ppu);
        ppu_layout->setObjectName("ppu_layout");
        ppu__static = new QRadioButton(gb_ppu);
        ppu__static->setObjectName("ppu__static");
        ppu__static->setText(QString::fromUtf8("Interpreter (static)"));

        ppu_layout->addWidget(ppu__static);

        ppu_llvm = new QRadioButton(gb_ppu);
        ppu_llvm->setObjectName("ppu_llvm");
        ppu_llvm->setText(QString::fromUtf8("LLVM Recompiler (fastest)"));

        ppu_layout->addWidget(ppu_llvm);


        coreTabLeftLayout->addWidget(gb_ppu);

        gb_spu = new QGroupBox(coreTab);
        gb_spu->setObjectName("gb_spu");
        spu_layout = new QVBoxLayout(gb_spu);
        spu_layout->setObjectName("spu_layout");
        spu__static = new QRadioButton(gb_spu);
        spu__static->setObjectName("spu__static");
        spu__static->setText(QString::fromUtf8("Interpreter (static)"));

        spu_layout->addWidget(spu__static);

        spu_dynamic = new QRadioButton(gb_spu);
        spu_dynamic->setObjectName("spu_dynamic");
        spu_dynamic->setText(QString::fromUtf8("Interpreter (dynamic)"));

        spu_layout->addWidget(spu_dynamic);

        spu_asmjit = new QRadioButton(gb_spu);
        spu_asmjit->setObjectName("spu_asmjit");
        spu_asmjit->setText(QString::fromUtf8("ASMJIT Recompiler (faster)"));

        spu_layout->addWidget(spu_asmjit);

        spu_llvm = new QRadioButton(gb_spu);
        spu_llvm->setObjectName("spu_llvm");
        spu_llvm->setText(QString::fromUtf8("LLVM Recompiler (fastest)"));

        spu_layout->addWidget(spu_llvm);


        coreTabLeftLayout->addWidget(gb_spu);

        coreTabLeftLayoutSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        coreTabLeftLayout->addItem(coreTabLeftLayoutSpacer);


        coreTabItemLayout->addLayout(coreTabLeftLayout);

        coreTabMiddleLayout = new QVBoxLayout();
        coreTabMiddleLayout->setObjectName("coreTabMiddleLayout");
        gb_xfloat_accuracy = new QGroupBox(coreTab);
        gb_xfloat_accuracy->setObjectName("gb_xfloat_accuracy");
        QSizePolicy sizePolicy1(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Minimum);
        sizePolicy1.setHorizontalStretch(0);
        sizePolicy1.setVerticalStretch(0);
        sizePolicy1.setHeightForWidth(gb_xfloat_accuracy->sizePolicy().hasHeightForWidth());
        gb_xfloat_accuracy->setSizePolicy(sizePolicy1);
        gb_xfloat_accuracy_layout = new QVBoxLayout(gb_xfloat_accuracy);
        gb_xfloat_accuracy_layout->setObjectName("gb_xfloat_accuracy_layout");
        xfloatAccuracy = new QComboBox(gb_xfloat_accuracy);
        xfloatAccuracy->setObjectName("xfloatAccuracy");

        gb_xfloat_accuracy_layout->addWidget(xfloatAccuracy);


        coreTabMiddleLayout->addWidget(gb_xfloat_accuracy);

        gb_spuBlockSize = new QGroupBox(coreTab);
        gb_spuBlockSize->setObjectName("gb_spuBlockSize");
        sizePolicy1.setHeightForWidth(gb_spuBlockSize->sizePolicy().hasHeightForWidth());
        gb_spuBlockSize->setSizePolicy(sizePolicy1);
        gb_spuBlockSize_layout = new QVBoxLayout(gb_spuBlockSize);
        gb_spuBlockSize_layout->setObjectName("gb_spuBlockSize_layout");
        spuBlockSize = new QComboBox(gb_spuBlockSize);
        spuBlockSize->setObjectName("spuBlockSize");

        gb_spuBlockSize_layout->addWidget(spuBlockSize);


        coreTabMiddleLayout->addWidget(gb_spuBlockSize);

        gb_max_preempt_count = new QGroupBox(coreTab);
        gb_max_preempt_count->setObjectName("gb_max_preempt_count");
        sizePolicy1.setHeightForWidth(gb_max_preempt_count->sizePolicy().hasHeightForWidth());
        gb_max_preempt_count->setSizePolicy(sizePolicy1);
        gb_max_preempt_layout = new QVBoxLayout(gb_max_preempt_count);
        gb_max_preempt_layout->setObjectName("gb_max_preempt_layout");
        maxPreemptCount = new QSlider(gb_max_preempt_count);
        maxPreemptCount->setObjectName("maxPreemptCount");
        sizePolicy1.setHeightForWidth(maxPreemptCount->sizePolicy().hasHeightForWidth());
        maxPreemptCount->setSizePolicy(sizePolicy1);
        maxPreemptCount->setOrientation(Qt::Orientation::Horizontal);

        gb_max_preempt_layout->addWidget(maxPreemptCount);

        maxPreemptLayout = new QHBoxLayout();
        maxPreemptLayout->setObjectName("maxPreemptLayout");
        preemptText = new QLabel(gb_max_preempt_count);
        preemptText->setObjectName("preemptText");
        preemptText->setAlignment(Qt::AlignmentFlag::AlignCenter);

        maxPreemptLayout->addWidget(preemptText);

        preemptReset = new QPushButton(gb_max_preempt_count);
        preemptReset->setObjectName("preemptReset");

        maxPreemptLayout->addWidget(preemptReset);


        gb_max_preempt_layout->addLayout(maxPreemptLayout);


        coreTabMiddleLayout->addWidget(gb_max_preempt_count);

        coreTabMiddleLayoutSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        coreTabMiddleLayout->addItem(coreTabMiddleLayoutSpacer);


        coreTabItemLayout->addLayout(coreTabMiddleLayout);

        coreTabRightLayout = new QVBoxLayout();
        coreTabRightLayout->setObjectName("coreTabRightLayout");
        gb_spu_threads = new QGroupBox(coreTab);
        gb_spu_threads->setObjectName("gb_spu_threads");
        sizePolicy1.setHeightForWidth(gb_spu_threads->sizePolicy().hasHeightForWidth());
        gb_spu_threads->setSizePolicy(sizePolicy1);
        gb_spu_threads_layout = new QVBoxLayout(gb_spu_threads);
        gb_spu_threads_layout->setObjectName("gb_spu_threads_layout");
        preferredSPUThreads = new QComboBox(gb_spu_threads);
        preferredSPUThreads->setObjectName("preferredSPUThreads");

        gb_spu_threads_layout->addWidget(preferredSPUThreads);


        coreTabRightLayout->addWidget(gb_spu_threads);

        gb_threadsched = new QGroupBox(coreTab);
        gb_threadsched->setObjectName("gb_threadsched");
        sizePolicy1.setHeightForWidth(gb_threadsched->sizePolicy().hasHeightForWidth());
        gb_threadsched->setSizePolicy(sizePolicy1);
        gb_threadsched_layout = new QVBoxLayout(gb_threadsched);
        gb_threadsched_layout->setObjectName("gb_threadsched_layout");
        threadsched = new QComboBox(gb_threadsched);
        threadsched->setObjectName("threadsched");

        gb_threadsched_layout->addWidget(threadsched);


        coreTabRightLayout->addWidget(gb_threadsched);

        coreTabRightLayoutSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        coreTabRightLayout->addItem(coreTabRightLayoutSpacer);


        coreTabItemLayout->addLayout(coreTabRightLayout);


        coreTabLayout->addLayout(coreTabItemLayout);

        coreTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        coreTabLayout->addItem(coreTabSpacer);

        gb_description_cpu = new QGroupBox(coreTab);
        gb_description_cpu->setObjectName("gb_description_cpu");
        gb_description_cpu_layout = new QVBoxLayout(gb_description_cpu);
        gb_description_cpu_layout->setObjectName("gb_description_cpu_layout");
        description_cpu = new QLabel(gb_description_cpu);
        description_cpu->setObjectName("description_cpu");
        description_cpu->setTextFormat(Qt::TextFormat::PlainText);
        description_cpu->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_cpu->setWordWrap(true);

        gb_description_cpu_layout->addWidget(description_cpu);


        coreTabLayout->addWidget(gb_description_cpu);

        coreTabLayout->setStretch(1, 1);
        tab_widget_settings->addTab(coreTab, QString());
        gpuTab = new QWidget();
        gpuTab->setObjectName("gpuTab");
        gpuTab_layout = new QVBoxLayout(gpuTab);
        gpuTab_layout->setObjectName("gpuTab_layout");
        gpuTabLayout = new QHBoxLayout();
        gpuTabLayout->setObjectName("gpuTabLayout");
        gpuTabLayoutLeft = new QVBoxLayout();
        gpuTabLayoutLeft->setObjectName("gpuTabLayoutLeft");
        gb_renderer = new QGroupBox(gpuTab);
        gb_renderer->setObjectName("gb_renderer");
        gb_renderer_layout = new QVBoxLayout(gb_renderer);
        gb_renderer_layout->setObjectName("gb_renderer_layout");
        renderBox = new QComboBox(gb_renderer);
        renderBox->setObjectName("renderBox");

        gb_renderer_layout->addWidget(renderBox);


        gpuTabLayoutLeft->addWidget(gb_renderer);

        gb_graphicsAdapter = new QGroupBox(gpuTab);
        gb_graphicsAdapter->setObjectName("gb_graphicsAdapter");
        gb_graphicsAdapter_layout = new QVBoxLayout(gb_graphicsAdapter);
        gb_graphicsAdapter_layout->setObjectName("gb_graphicsAdapter_layout");
        graphicsAdapterBox = new QComboBox(gb_graphicsAdapter);
        graphicsAdapterBox->setObjectName("graphicsAdapterBox");

        gb_graphicsAdapter_layout->addWidget(graphicsAdapterBox);


        gpuTabLayoutLeft->addWidget(gb_graphicsAdapter);

        widget_gpu_top = new QWidget(gpuTab);
        widget_gpu_top->setObjectName("widget_gpu_top");
        widget_gpu_top_layout = new QHBoxLayout(widget_gpu_top);
        widget_gpu_top_layout->setObjectName("widget_gpu_top_layout");
        widget_gpu_top_layout->setContentsMargins(0, 0, 0, 0);
        gb_aspectRatio = new QGroupBox(widget_gpu_top);
        gb_aspectRatio->setObjectName("gb_aspectRatio");
        gb_aspectRatio_layout = new QVBoxLayout(gb_aspectRatio);
        gb_aspectRatio_layout->setObjectName("gb_aspectRatio_layout");
        aspectBox = new QComboBox(gb_aspectRatio);
        aspectBox->setObjectName("aspectBox");

        gb_aspectRatio_layout->addWidget(aspectBox);


        widget_gpu_top_layout->addWidget(gb_aspectRatio);

        gb_frameLimit = new QGroupBox(widget_gpu_top);
        gb_frameLimit->setObjectName("gb_frameLimit");
        gb_frameLimit_layout = new QVBoxLayout(gb_frameLimit);
        gb_frameLimit_layout->setObjectName("gb_frameLimit_layout");
        frameLimitBox = new QComboBox(gb_frameLimit);
        frameLimitBox->setObjectName("frameLimitBox");

        gb_frameLimit_layout->addWidget(frameLimitBox);


        widget_gpu_top_layout->addWidget(gb_frameLimit);

        widget_gpu_top_layout->setStretch(0, 1);
        widget_gpu_top_layout->setStretch(1, 1);

        gpuTabLayoutLeft->addWidget(widget_gpu_top);

        widget_gpu_bottom = new QWidget(gpuTab);
        widget_gpu_bottom->setObjectName("widget_gpu_bottom");
        widget_gpu_bottom_layout = new QHBoxLayout(widget_gpu_bottom);
        widget_gpu_bottom_layout->setObjectName("widget_gpu_bottom_layout");
        widget_gpu_bottom_layout->setContentsMargins(0, 0, 0, 0);
        gb_anisotropicFilter = new QGroupBox(widget_gpu_bottom);
        gb_anisotropicFilter->setObjectName("gb_anisotropicFilter");
        gb_anisotropicFilter_layout = new QVBoxLayout(gb_anisotropicFilter);
        gb_anisotropicFilter_layout->setObjectName("gb_anisotropicFilter_layout");
        anisotropicFilterOverride = new QComboBox(gb_anisotropicFilter);
        anisotropicFilterOverride->setObjectName("anisotropicFilterOverride");

        gb_anisotropicFilter_layout->addWidget(anisotropicFilterOverride);


        widget_gpu_bottom_layout->addWidget(gb_anisotropicFilter);

        gb_antiAliasing = new QGroupBox(widget_gpu_bottom);
        gb_antiAliasing->setObjectName("gb_antiAliasing");
        gb_antiAliasing_layout = new QVBoxLayout(gb_antiAliasing);
        gb_antiAliasing_layout->setObjectName("gb_antiAliasing_layout");
        antiAliasing = new QComboBox(gb_antiAliasing);
        antiAliasing->setObjectName("antiAliasing");

        gb_antiAliasing_layout->addWidget(antiAliasing);


        widget_gpu_bottom_layout->addWidget(gb_antiAliasing);

        widget_gpu_bottom_layout->setStretch(0, 1);
        widget_gpu_bottom_layout->setStretch(1, 1);

        gpuTabLayoutLeft->addWidget(widget_gpu_bottom);

        widget_gpu_3 = new QWidget(gpuTab);
        widget_gpu_3->setObjectName("widget_gpu_3");
        widget_gpu_3_layout = new QHBoxLayout(widget_gpu_3);
        widget_gpu_3_layout->setObjectName("widget_gpu_3_layout");
        widget_gpu_3_layout->setContentsMargins(0, 0, 0, 0);
        gbZCULL = new QGroupBox(widget_gpu_3);
        gbZCULL->setObjectName("gbZCULL");
        gbZCULL_layout = new QVBoxLayout(gbZCULL);
        gbZCULL_layout->setObjectName("gbZCULL_layout");
        zcullPrecisionMode = new QComboBox(gbZCULL);
        zcullPrecisionMode->setObjectName("zcullPrecisionMode");

        gbZCULL_layout->addWidget(zcullPrecisionMode);


        widget_gpu_3_layout->addWidget(gbZCULL);

        gbShaderPrecision = new QGroupBox(widget_gpu_3);
        gbShaderPrecision->setObjectName("gbShaderPrecision");
        gbShaderPrecision_layout = new QVBoxLayout(gbShaderPrecision);
        gbShaderPrecision_layout->setObjectName("gbShaderPrecision_layout");
        shaderPrecision = new QComboBox(gbShaderPrecision);
        shaderPrecision->setObjectName("shaderPrecision");

        gbShaderPrecision_layout->addWidget(shaderPrecision);


        widget_gpu_3_layout->addWidget(gbShaderPrecision);

        widget_gpu_3_layout->setStretch(0, 1);
        widget_gpu_3_layout->setStretch(1, 1);

        gpuTabLayoutLeft->addWidget(widget_gpu_3);

        widget_gpu_4 = new QWidget(gpuTab);
        widget_gpu_4->setObjectName("widget_gpu_4");
        widget_gpu_4_layout = new QHBoxLayout(widget_gpu_4);
        widget_gpu_4_layout->setObjectName("widget_gpu_4_layout");
        widget_gpu_4_layout->setContentsMargins(0, 0, 0, 0);
        gbVsync = new QGroupBox(widget_gpu_4);
        gbVsync->setObjectName("gbVsync");
        gbVsync_layout = new QVBoxLayout(gbVsync);
        gbVsync_layout->setObjectName("gbVsync_layout");
        vsyncMode = new QComboBox(gbVsync);
        vsyncMode->setObjectName("vsyncMode");

        gbVsync_layout->addWidget(vsyncMode);


        widget_gpu_4_layout->addWidget(gbVsync);

        widget_gpu_4_layout->setStretch(0, 1);

        gpuTabLayoutLeft->addWidget(widget_gpu_4);

        gb_stereo = new QGroupBox(gpuTab);
        gb_stereo->setObjectName("gb_stereo");
        gb_stereo_layout = new QVBoxLayout(gb_stereo);
        gb_stereo_layout->setObjectName("gb_stereo_layout");
        stereoRenderEnabled = new QCheckBox(gb_stereo);
        stereoRenderEnabled->setObjectName("stereoRenderEnabled");

        gb_stereo_layout->addWidget(stereoRenderEnabled);

        stereoRenderMode = new QComboBox(gb_stereo);
        stereoRenderMode->setObjectName("stereoRenderMode");

        gb_stereo_layout->addWidget(stereoRenderMode);

        gb_screen_size = new QGroupBox(gb_stereo);
        gb_screen_size->setObjectName("gb_screen_size");
        layout_gb_screen_size = new QVBoxLayout(gb_screen_size);
        layout_gb_screen_size->setObjectName("layout_gb_screen_size");
        sb_screen_size = new QSpinBox(gb_screen_size);
        sb_screen_size->setObjectName("sb_screen_size");

        layout_gb_screen_size->addWidget(sb_screen_size);


        gb_stereo_layout->addWidget(gb_screen_size);


        gpuTabLayoutLeft->addWidget(gb_stereo);

        gpu_tab_layout_right_spacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gpuTabLayoutLeft->addItem(gpu_tab_layout_right_spacer);


        gpuTabLayout->addLayout(gpuTabLayoutLeft);

        gpuTabLayoutMiddle = new QVBoxLayout();
        gpuTabLayoutMiddle->setObjectName("gpuTabLayoutMiddle");
        gb_default_resolution = new QGroupBox(gpuTab);
        gb_default_resolution->setObjectName("gb_default_resolution");
        gb_default_resolution_layout = new QVBoxLayout(gb_default_resolution);
        gb_default_resolution_layout->setObjectName("gb_default_resolution_layout");
        resBox = new QComboBox(gb_default_resolution);
        resBox->setObjectName("resBox");

        gb_default_resolution_layout->addWidget(resBox);


        gpuTabLayoutMiddle->addWidget(gb_default_resolution);

        layout_resolution_scale = new QVBoxLayout();
        layout_resolution_scale->setSpacing(6);
        layout_resolution_scale->setObjectName("layout_resolution_scale");
        layout_resolution_scale->setContentsMargins(0, -1, -1, -1);
        gb_resolutionScale = new QGroupBox(gpuTab);
        gb_resolutionScale->setObjectName("gb_resolutionScale");
        gb_resolutionScale_layout = new QVBoxLayout(gb_resolutionScale);
        gb_resolutionScale_layout->setObjectName("gb_resolutionScale_layout");
        resolutionScaleLayoutTop = new QWidget(gb_resolutionScale);
        resolutionScaleLayoutTop->setObjectName("resolutionScaleLayoutTop");
        horizontalLayout_23 = new QHBoxLayout(resolutionScaleLayoutTop);
        horizontalLayout_23->setSpacing(12);
        horizontalLayout_23->setObjectName("horizontalLayout_23");
        horizontalLayout_23->setContentsMargins(0, 0, 0, 0);
        resolutionScaleMin = new QLabel(resolutionScaleLayoutTop);
        resolutionScaleMin->setObjectName("resolutionScaleMin");
        resolutionScaleMin->setAlignment(Qt::AlignmentFlag::AlignRight|Qt::AlignmentFlag::AlignTrailing|Qt::AlignmentFlag::AlignVCenter);

        horizontalLayout_23->addWidget(resolutionScaleMin);

        resolutionScale = new QSlider(resolutionScaleLayoutTop);
        resolutionScale->setObjectName("resolutionScale");
        resolutionScale->setOrientation(Qt::Orientation::Horizontal);

        horizontalLayout_23->addWidget(resolutionScale);

        resolutionScaleMax = new QLabel(resolutionScaleLayoutTop);
        resolutionScaleMax->setObjectName("resolutionScaleMax");

        horizontalLayout_23->addWidget(resolutionScaleMax);

        horizontalLayout_23->setStretch(1, 1);

        gb_resolutionScale_layout->addWidget(resolutionScaleLayoutTop);

        resolutionScaleLayoutBottom = new QHBoxLayout();
        resolutionScaleLayoutBottom->setObjectName("resolutionScaleLayoutBottom");
        resolutionScaleVal = new QLabel(gb_resolutionScale);
        resolutionScaleVal->setObjectName("resolutionScaleVal");
        resolutionScaleVal->setAlignment(Qt::AlignmentFlag::AlignCenter);

        resolutionScaleLayoutBottom->addWidget(resolutionScaleVal);

        resolutionScaleReset = new QPushButton(gb_resolutionScale);
        resolutionScaleReset->setObjectName("resolutionScaleReset");

        resolutionScaleLayoutBottom->addWidget(resolutionScaleReset);

        resolutionScaleLayoutBottom->setStretch(0, 1);

        gb_resolutionScale_layout->addLayout(resolutionScaleLayoutBottom);


        layout_resolution_scale->addWidget(gb_resolutionScale);

        gb_minimumScalableDimension = new QGroupBox(gpuTab);
        gb_minimumScalableDimension->setObjectName("gb_minimumScalableDimension");
        gb_minimumScalableDimension_layout = new QVBoxLayout(gb_minimumScalableDimension);
        gb_minimumScalableDimension_layout->setObjectName("gb_minimumScalableDimension_layout");
        minimumScalableDimensionLayoutTop = new QHBoxLayout();
        minimumScalableDimensionLayoutTop->setSpacing(12);
        minimumScalableDimensionLayoutTop->setObjectName("minimumScalableDimensionLayoutTop");
        minimumScalableDimensionMin = new QLabel(gb_minimumScalableDimension);
        minimumScalableDimensionMin->setObjectName("minimumScalableDimensionMin");
        minimumScalableDimensionMin->setAlignment(Qt::AlignmentFlag::AlignRight|Qt::AlignmentFlag::AlignTrailing|Qt::AlignmentFlag::AlignVCenter);

        minimumScalableDimensionLayoutTop->addWidget(minimumScalableDimensionMin);

        minimumScalableDimension = new QSlider(gb_minimumScalableDimension);
        minimumScalableDimension->setObjectName("minimumScalableDimension");
        minimumScalableDimension->setOrientation(Qt::Orientation::Horizontal);

        minimumScalableDimensionLayoutTop->addWidget(minimumScalableDimension);

        minimumScalableDimensionMax = new QLabel(gb_minimumScalableDimension);
        minimumScalableDimensionMax->setObjectName("minimumScalableDimensionMax");

        minimumScalableDimensionLayoutTop->addWidget(minimumScalableDimensionMax);

        minimumScalableDimensionLayoutTop->setStretch(1, 1);

        gb_minimumScalableDimension_layout->addLayout(minimumScalableDimensionLayoutTop);

        minimumScalableDimensionLayoutBottom = new QHBoxLayout();
        minimumScalableDimensionLayoutBottom->setObjectName("minimumScalableDimensionLayoutBottom");
        minimumScalableDimensionVal = new QLabel(gb_minimumScalableDimension);
        minimumScalableDimensionVal->setObjectName("minimumScalableDimensionVal");
        minimumScalableDimensionVal->setAlignment(Qt::AlignmentFlag::AlignCenter);

        minimumScalableDimensionLayoutBottom->addWidget(minimumScalableDimensionVal);

        minimumScalableDimensionReset = new QPushButton(gb_minimumScalableDimension);
        minimumScalableDimensionReset->setObjectName("minimumScalableDimensionReset");

        minimumScalableDimensionLayoutBottom->addWidget(minimumScalableDimensionReset);

        minimumScalableDimensionLayoutBottom->setStretch(0, 1);

        gb_minimumScalableDimension_layout->addLayout(minimumScalableDimensionLayoutBottom);


        layout_resolution_scale->addWidget(gb_minimumScalableDimension);


        gpuTabLayoutMiddle->addLayout(layout_resolution_scale);

        gb_outputScaling = new QGroupBox(gpuTab);
        gb_outputScaling->setObjectName("gb_outputScaling");
        gb_Upscaling_layout = new QVBoxLayout(gb_outputScaling);
        gb_Upscaling_layout->setObjectName("gb_Upscaling_layout");
        outputScalingMode = new QComboBox(gb_outputScaling);
        outputScalingMode->setObjectName("outputScalingMode");

        gb_Upscaling_layout->addWidget(outputScalingMode);

        line = new QFrame(gb_outputScaling);
        line->setObjectName("line");
        line->setFrameShape(QFrame::Shape::HLine);
        line->setFrameShadow(QFrame::Shadow::Sunken);

        gb_Upscaling_layout->addWidget(line);

        fsrSharpeningStrengthWidget = new QWidget(gb_outputScaling);
        fsrSharpeningStrengthWidget->setObjectName("fsrSharpeningStrengthWidget");
        fsrSharpeningWidgetLayout = new QVBoxLayout(fsrSharpeningStrengthWidget);
        fsrSharpeningWidgetLayout->setObjectName("fsrSharpeningWidgetLayout");
        fsrSharpeningWidgetLayout->setContentsMargins(0, 0, 0, 0);
        fsrSharpeningStrengthLabel = new QLabel(fsrSharpeningStrengthWidget);
        fsrSharpeningStrengthLabel->setObjectName("fsrSharpeningStrengthLabel");
        sizePolicy.setHeightForWidth(fsrSharpeningStrengthLabel->sizePolicy().hasHeightForWidth());
        fsrSharpeningStrengthLabel->setSizePolicy(sizePolicy);
        fsrSharpeningStrengthLabel->setAlignment(Qt::AlignmentFlag::AlignBottom|Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft);
        fsrSharpeningStrengthLabel->setMargin(1);

        fsrSharpeningWidgetLayout->addWidget(fsrSharpeningStrengthLabel);

        fsrSharpeningLayoutTop = new QHBoxLayout();
        fsrSharpeningLayoutTop->setObjectName("fsrSharpeningLayoutTop");
        minSharpeningVal = new QLabel(fsrSharpeningStrengthWidget);
        minSharpeningVal->setObjectName("minSharpeningVal");

        fsrSharpeningLayoutTop->addWidget(minSharpeningVal);

        fsrSharpeningStrength = new QSlider(fsrSharpeningStrengthWidget);
        fsrSharpeningStrength->setObjectName("fsrSharpeningStrength");
        fsrSharpeningStrength->setOrientation(Qt::Orientation::Horizontal);

        fsrSharpeningLayoutTop->addWidget(fsrSharpeningStrength);

        maxSharpeningVal = new QLabel(fsrSharpeningStrengthWidget);
        maxSharpeningVal->setObjectName("maxSharpeningVal");
        QSizePolicy sizePolicy2(QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Preferred);
        sizePolicy2.setHorizontalStretch(0);
        sizePolicy2.setVerticalStretch(0);
        sizePolicy2.setHeightForWidth(maxSharpeningVal->sizePolicy().hasHeightForWidth());
        maxSharpeningVal->setSizePolicy(sizePolicy2);

        fsrSharpeningLayoutTop->addWidget(maxSharpeningVal);


        fsrSharpeningWidgetLayout->addLayout(fsrSharpeningLayoutTop);

        fsrSharpeningLayoutBottom = new QHBoxLayout();
        fsrSharpeningLayoutBottom->setObjectName("fsrSharpeningLayoutBottom");
        fsrSharpeningStrengthVal = new QLabel(fsrSharpeningStrengthWidget);
        fsrSharpeningStrengthVal->setObjectName("fsrSharpeningStrengthVal");
        fsrSharpeningStrengthVal->setAlignment(Qt::AlignmentFlag::AlignCenter);

        fsrSharpeningLayoutBottom->addWidget(fsrSharpeningStrengthVal);

        fsrSharpeningStrengthReset = new QPushButton(fsrSharpeningStrengthWidget);
        fsrSharpeningStrengthReset->setObjectName("fsrSharpeningStrengthReset");

        fsrSharpeningLayoutBottom->addWidget(fsrSharpeningStrengthReset);

        fsrSharpeningLayoutBottom->setStretch(0, 1);

        fsrSharpeningWidgetLayout->addLayout(fsrSharpeningLayoutBottom);


        gb_Upscaling_layout->addWidget(fsrSharpeningStrengthWidget);


        gpuTabLayoutMiddle->addWidget(gb_outputScaling);

        gpu_tab_layout_middle_spacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gpuTabLayoutMiddle->addItem(gpu_tab_layout_middle_spacer);


        gpuTabLayout->addLayout(gpuTabLayoutMiddle);

        gpuTabLayoutRight = new QVBoxLayout();
        gpuTabLayoutRight->setObjectName("gpuTabLayoutRight");
        gpuTabLayoutRight->setContentsMargins(-1, -1, 12, 12);
        gb_shader_mode = new QGroupBox(gpuTab);
        gb_shader_mode->setObjectName("gb_shader_mode");
        gb_shader_mode->setMinimumSize(QSize(0, 123));
        verticalLayout = new QVBoxLayout(gb_shader_mode);
        verticalLayout->setObjectName("verticalLayout");
        rb_legacy_recompiler = new QRadioButton(gb_shader_mode);
        rb_legacy_recompiler->setObjectName("rb_legacy_recompiler");
        rb_legacy_recompiler->setText(QString::fromUtf8("Legacy (single threaded)"));

        verticalLayout->addWidget(rb_legacy_recompiler);

        rb_async_recompiler = new QRadioButton(gb_shader_mode);
        rb_async_recompiler->setObjectName("rb_async_recompiler");
        rb_async_recompiler->setText(QString::fromUtf8("Async (multi threaded)"));

        verticalLayout->addWidget(rb_async_recompiler);

        rb_async_with_shader_interpreter = new QRadioButton(gb_shader_mode);
        rb_async_with_shader_interpreter->setObjectName("rb_async_with_shader_interpreter");
        rb_async_with_shader_interpreter->setText(QString::fromUtf8("Async with Shader Interpreter"));

        verticalLayout->addWidget(rb_async_with_shader_interpreter);

        rb_shader_interpreter_only = new QRadioButton(gb_shader_mode);
        rb_shader_interpreter_only->setObjectName("rb_shader_interpreter_only");
        rb_shader_interpreter_only->setText(QString::fromUtf8("Shader Interpreter only"));

        verticalLayout->addWidget(rb_shader_interpreter_only);


        gpuTabLayoutRight->addWidget(gb_shader_mode);

        gb_additional_settings = new QGroupBox(gpuTab);
        gb_additional_settings->setObjectName("gb_additional_settings");
        gb_additional_settings->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignVCenter);
        gb_additional_settings_layout = new QVBoxLayout(gb_additional_settings);
        gb_additional_settings_layout->setObjectName("gb_additional_settings_layout");
        dumpColor = new QCheckBox(gb_additional_settings);
        dumpColor->setObjectName("dumpColor");

        gb_additional_settings_layout->addWidget(dumpColor);

        strictModeRendering = new QCheckBox(gb_additional_settings);
        strictModeRendering->setObjectName("strictModeRendering");

        gb_additional_settings_layout->addWidget(strictModeRendering);

        stretchToDisplayArea = new QCheckBox(gb_additional_settings);
        stretchToDisplayArea->setObjectName("stretchToDisplayArea");

        gb_additional_settings_layout->addWidget(stretchToDisplayArea);

        multithreadedRSX = new QCheckBox(gb_additional_settings);
        multithreadedRSX->setObjectName("multithreadedRSX");

        gb_additional_settings_layout->addWidget(multithreadedRSX);

        asyncTextureStreaming = new QCheckBox(gb_additional_settings);
        asyncTextureStreaming->setObjectName("asyncTextureStreaming");

        gb_additional_settings_layout->addWidget(asyncTextureStreaming);

        additional_settings_spacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_additional_settings_layout->addItem(additional_settings_spacer);


        gpuTabLayoutRight->addWidget(gb_additional_settings);


        gpuTabLayout->addLayout(gpuTabLayoutRight);

        gpuTabLayout->setStretch(0, 1);
        gpuTabLayout->setStretch(1, 1);
        gpuTabLayout->setStretch(2, 1);

        gpuTab_layout->addLayout(gpuTabLayout);

        gpuTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gpuTab_layout->addItem(gpuTabSpacer);

        gb_description_gpu = new QGroupBox(gpuTab);
        gb_description_gpu->setObjectName("gb_description_gpu");
        gb_description_gpu_layout = new QHBoxLayout(gb_description_gpu);
        gb_description_gpu_layout->setObjectName("gb_description_gpu_layout");
        description_gpu = new QLabel(gb_description_gpu);
        description_gpu->setObjectName("description_gpu");
        description_gpu->setTextFormat(Qt::TextFormat::PlainText);
        description_gpu->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_gpu->setWordWrap(true);

        gb_description_gpu_layout->addWidget(description_gpu);


        gpuTab_layout->addWidget(gb_description_gpu);

        gpuTab_layout->setStretch(1, 1);
        tab_widget_settings->addTab(gpuTab, QString());
        audioTab = new QWidget();
        audioTab->setObjectName("audioTab");
        audioTab_layout = new QVBoxLayout(audioTab);
        audioTab_layout->setObjectName("audioTab_layout");
        audioTabLayoutTop = new QHBoxLayout();
        audioTabLayoutTop->setObjectName("audioTabLayoutTop");
        audioTabLayoutTopLeft = new QVBoxLayout();
        audioTabLayoutTopLeft->setObjectName("audioTabLayoutTopLeft");
        gb_audio_out = new QGroupBox(audioTab);
        gb_audio_out->setObjectName("gb_audio_out");
        gb_audio_out_layout = new QVBoxLayout(gb_audio_out);
        gb_audio_out_layout->setObjectName("gb_audio_out_layout");
        audioOutBox = new QComboBox(gb_audio_out);
        audioOutBox->setObjectName("audioOutBox");

        gb_audio_out_layout->addWidget(audioOutBox);


        audioTabLayoutTopLeft->addWidget(gb_audio_out);

        gb_audio_format = new QGroupBox(audioTab);
        gb_audio_format->setObjectName("gb_audio_format");
        gb_audio_format_layout = new QVBoxLayout(gb_audio_format);
        gb_audio_format_layout->setObjectName("gb_audio_format_layout");
        combo_audio_format = new QComboBox(gb_audio_format);
        combo_audio_format->setObjectName("combo_audio_format");

        gb_audio_format_layout->addWidget(combo_audio_format);

        list_audio_formats = new QListWidget(gb_audio_format);
        list_audio_formats->setObjectName("list_audio_formats");
        sizePolicy.setHeightForWidth(list_audio_formats->sizePolicy().hasHeightForWidth());
        list_audio_formats->setSizePolicy(sizePolicy);
        list_audio_formats->setSelectionMode(QAbstractItemView::SelectionMode::ExtendedSelection);

        gb_audio_format_layout->addWidget(list_audio_formats);


        audioTabLayoutTopLeft->addWidget(gb_audio_format);

        gb_audio_settings = new QGroupBox(audioTab);
        gb_audio_settings->setObjectName("gb_audio_settings");
        gb_audio_settings_layout = new QVBoxLayout(gb_audio_settings);
        gb_audio_settings_layout->setObjectName("gb_audio_settings_layout");
        convert = new QCheckBox(gb_audio_settings);
        convert->setObjectName("convert");

        gb_audio_settings_layout->addWidget(convert);

        audioDump = new QCheckBox(gb_audio_settings);
        audioDump->setObjectName("audioDump");

        gb_audio_settings_layout->addWidget(audioDump);

        spacer_audio_settings = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_audio_settings_layout->addItem(spacer_audio_settings);


        audioTabLayoutTopLeft->addWidget(gb_audio_settings);

        verticalSpacerAudioLeft = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        audioTabLayoutTopLeft->addItem(verticalSpacerAudioLeft);


        audioTabLayoutTop->addLayout(audioTabLayoutTopLeft);

        audioTabLayoutTopMiddle = new QVBoxLayout();
        audioTabLayoutTopMiddle->setObjectName("audioTabLayoutTopMiddle");
        gb_audio_device = new QGroupBox(audioTab);
        gb_audio_device->setObjectName("gb_audio_device");
        gb_audio_device_layout = new QVBoxLayout(gb_audio_device);
        gb_audio_device_layout->setObjectName("gb_audio_device_layout");
        audioDeviceBox = new QComboBox(gb_audio_device);
        audioDeviceBox->setObjectName("audioDeviceBox");

        gb_audio_device_layout->addWidget(audioDeviceBox);


        audioTabLayoutTopMiddle->addWidget(gb_audio_device);

        gb_audio_channel_layout = new QGroupBox(audioTab);
        gb_audio_channel_layout->setObjectName("gb_audio_channel_layout");
        gb_audio_channel_layout_layout = new QVBoxLayout(gb_audio_channel_layout);
        gb_audio_channel_layout_layout->setObjectName("gb_audio_channel_layout_layout");
        combo_audio_channel_layout = new QComboBox(gb_audio_channel_layout);
        combo_audio_channel_layout->setObjectName("combo_audio_channel_layout");

        gb_audio_channel_layout_layout->addWidget(combo_audio_channel_layout);


        audioTabLayoutTopMiddle->addWidget(gb_audio_channel_layout);

        gb_audio_provider = new QGroupBox(audioTab);
        gb_audio_provider->setObjectName("gb_audio_provider");
        gb_audio_provider_layout = new QVBoxLayout(gb_audio_provider);
        gb_audio_provider_layout->setObjectName("gb_audio_provider_layout");
        audioProviderBox = new QComboBox(gb_audio_provider);
        audioProviderBox->setObjectName("audioProviderBox");

        gb_audio_provider_layout->addWidget(audioProviderBox);


        audioTabLayoutTopMiddle->addWidget(gb_audio_provider);

        gb_audio_avport = new QGroupBox(audioTab);
        gb_audio_avport->setObjectName("gb_audio_avport");
        gb_audio_avport_layout = new QVBoxLayout(gb_audio_avport);
        gb_audio_avport_layout->setObjectName("gb_audio_avport_layout");
        audioAvportBox = new QComboBox(gb_audio_avport);
        audioAvportBox->setObjectName("audioAvportBox");

        gb_audio_avport_layout->addWidget(audioAvportBox);


        audioTabLayoutTopMiddle->addWidget(gb_audio_avport);

        gb_music_handler = new QGroupBox(audioTab);
        gb_music_handler->setObjectName("gb_music_handler");
        gb_music_handler_layout = new QVBoxLayout(gb_music_handler);
        gb_music_handler_layout->setObjectName("gb_music_handler_layout");
        musicHandlerBox = new QComboBox(gb_music_handler);
        musicHandlerBox->setObjectName("musicHandlerBox");

        gb_music_handler_layout->addWidget(musicHandlerBox);


        audioTabLayoutTopMiddle->addWidget(gb_music_handler);

        gb_audio_volume = new QGroupBox(audioTab);
        gb_audio_volume->setObjectName("gb_audio_volume");
        gb_audio_volume_layout = new QVBoxLayout(gb_audio_volume);
        gb_audio_volume_layout->setObjectName("gb_audio_volume_layout");
        master_volume = new QWidget(gb_audio_volume);
        master_volume->setObjectName("master_volume");
        layout_master_volume = new QVBoxLayout(master_volume);
        layout_master_volume->setObjectName("layout_master_volume");
        layout_master_volume->setContentsMargins(0, 0, 0, 0);
        masterVolumeLabel = new QLabel(master_volume);
        masterVolumeLabel->setObjectName("masterVolumeLabel");

        layout_master_volume->addWidget(masterVolumeLabel);

        masterVolume = new QSlider(master_volume);
        masterVolume->setObjectName("masterVolume");
        masterVolume->setOrientation(Qt::Orientation::Horizontal);
        masterVolume->setTickPosition(QSlider::TickPosition::TicksBelow);
        masterVolume->setTickInterval(50);

        layout_master_volume->addWidget(masterVolume);


        gb_audio_volume_layout->addWidget(master_volume);

        spacer_audio_volume = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_audio_volume_layout->addItem(spacer_audio_volume);


        audioTabLayoutTopMiddle->addWidget(gb_audio_volume);


        audioTabLayoutTop->addLayout(audioTabLayoutTopMiddle);

        audioTabLayoutTopRight = new QVBoxLayout();
        audioTabLayoutTopRight->setObjectName("audioTabLayoutTopRight");
        gb_audio_buffering = new QGroupBox(audioTab);
        gb_audio_buffering->setObjectName("gb_audio_buffering");
        gb_audio_buffering_layout = new QVBoxLayout(gb_audio_buffering);
        gb_audio_buffering_layout->setObjectName("gb_audio_buffering_layout");
        enableBuffering = new QCheckBox(gb_audio_buffering);
        enableBuffering->setObjectName("enableBuffering");

        gb_audio_buffering_layout->addWidget(enableBuffering);

        audio_buffer_duration = new QWidget(gb_audio_buffering);
        audio_buffer_duration->setObjectName("audio_buffer_duration");
        layout_audio_buffer_duration = new QVBoxLayout(audio_buffer_duration);
        layout_audio_buffer_duration->setObjectName("layout_audio_buffer_duration");
        layout_audio_buffer_duration->setContentsMargins(0, 0, 0, 0);
        audioBufferDurationLabel = new QLabel(audio_buffer_duration);
        audioBufferDurationLabel->setObjectName("audioBufferDurationLabel");

        layout_audio_buffer_duration->addWidget(audioBufferDurationLabel);

        audioBufferDuration = new QSlider(audio_buffer_duration);
        audioBufferDuration->setObjectName("audioBufferDuration");
        audioBufferDuration->setOrientation(Qt::Orientation::Horizontal);
        audioBufferDuration->setTickPosition(QSlider::TickPosition::TicksBelow);
        audioBufferDuration->setTickInterval(10);

        layout_audio_buffer_duration->addWidget(audioBufferDuration);


        gb_audio_buffering_layout->addWidget(audio_buffer_duration);

        enableTimeStretching = new QCheckBox(gb_audio_buffering);
        enableTimeStretching->setObjectName("enableTimeStretching");

        gb_audio_buffering_layout->addWidget(enableTimeStretching);

        time_stretching_threshold = new QWidget(gb_audio_buffering);
        time_stretching_threshold->setObjectName("time_stretching_threshold");
        layout_time_stretching_threshold = new QVBoxLayout(time_stretching_threshold);
        layout_time_stretching_threshold->setObjectName("layout_time_stretching_threshold");
        layout_time_stretching_threshold->setContentsMargins(0, 0, 0, 0);
        timeStretchingThresholdLabel = new QLabel(time_stretching_threshold);
        timeStretchingThresholdLabel->setObjectName("timeStretchingThresholdLabel");

        layout_time_stretching_threshold->addWidget(timeStretchingThresholdLabel);

        timeStretchingThreshold = new QSlider(time_stretching_threshold);
        timeStretchingThreshold->setObjectName("timeStretchingThreshold");
        timeStretchingThreshold->setOrientation(Qt::Orientation::Horizontal);
        timeStretchingThreshold->setTickPosition(QSlider::TickPosition::TicksBelow);
        timeStretchingThreshold->setTickInterval(10);

        layout_time_stretching_threshold->addWidget(timeStretchingThreshold);


        gb_audio_buffering_layout->addWidget(time_stretching_threshold);

        verticalSpacerAudioRight = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_audio_buffering_layout->addItem(verticalSpacerAudioRight);


        audioTabLayoutTopRight->addWidget(gb_audio_buffering);


        audioTabLayoutTop->addLayout(audioTabLayoutTopRight);

        audioTabLayoutTop->setStretch(0, 1);
        audioTabLayoutTop->setStretch(1, 1);
        audioTabLayoutTop->setStretch(2, 1);

        audioTab_layout->addLayout(audioTabLayoutTop);

        gb_microphone_settings = new QGroupBox(audioTab);
        gb_microphone_settings->setObjectName("gb_microphone_settings");
        gb_microphone_settings_layout = new QVBoxLayout(gb_microphone_settings);
        gb_microphone_settings_layout->setObjectName("gb_microphone_settings_layout");
        microphoneLayoutTop = new QHBoxLayout();
        microphoneLayoutTop->setObjectName("microphoneLayoutTop");
        microphoneLabel = new QLabel(gb_microphone_settings);
        microphoneLabel->setObjectName("microphoneLabel");

        microphoneLayoutTop->addWidget(microphoneLabel);

        microphoneBox = new QComboBox(gb_microphone_settings);
        microphoneBox->setObjectName("microphoneBox");

        microphoneLayoutTop->addWidget(microphoneBox);

        microphoneSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::MinimumExpanding, QSizePolicy::Policy::Minimum);

        microphoneLayoutTop->addItem(microphoneSpacer);


        gb_microphone_settings_layout->addLayout(microphoneLayoutTop);

        microphoneLayoutBottom = new QHBoxLayout();
        microphoneLayoutBottom->setObjectName("microphoneLayoutBottom");
        microphoneLayoutLabel1and3 = new QVBoxLayout();
        microphoneLayoutLabel1and3->setObjectName("microphoneLayoutLabel1and3");
        microphone1Label = new QLabel(gb_microphone_settings);
        microphone1Label->setObjectName("microphone1Label");
        sizePolicy2.setHeightForWidth(microphone1Label->sizePolicy().hasHeightForWidth());
        microphone1Label->setSizePolicy(sizePolicy2);

        microphoneLayoutLabel1and3->addWidget(microphone1Label);

        microphone3Label = new QLabel(gb_microphone_settings);
        microphone3Label->setObjectName("microphone3Label");
        sizePolicy2.setHeightForWidth(microphone3Label->sizePolicy().hasHeightForWidth());
        microphone3Label->setSizePolicy(sizePolicy2);

        microphoneLayoutLabel1and3->addWidget(microphone3Label);


        microphoneLayoutBottom->addLayout(microphoneLayoutLabel1and3);

        microphoneLayoutBox1and3 = new QVBoxLayout();
        microphoneLayoutBox1and3->setObjectName("microphoneLayoutBox1and3");
        microphone1Box = new QComboBox(gb_microphone_settings);
        microphone1Box->setObjectName("microphone1Box");
        QSizePolicy sizePolicy3(QSizePolicy::Policy::Expanding, QSizePolicy::Policy::Fixed);
        sizePolicy3.setHorizontalStretch(0);
        sizePolicy3.setVerticalStretch(0);
        sizePolicy3.setHeightForWidth(microphone1Box->sizePolicy().hasHeightForWidth());
        microphone1Box->setSizePolicy(sizePolicy3);

        microphoneLayoutBox1and3->addWidget(microphone1Box);

        microphone3Box = new QComboBox(gb_microphone_settings);
        microphone3Box->setObjectName("microphone3Box");
        sizePolicy3.setHeightForWidth(microphone3Box->sizePolicy().hasHeightForWidth());
        microphone3Box->setSizePolicy(sizePolicy3);

        microphoneLayoutBox1and3->addWidget(microphone3Box);


        microphoneLayoutBottom->addLayout(microphoneLayoutBox1and3);

        microphoneLayoutLabel2and4 = new QVBoxLayout();
        microphoneLayoutLabel2and4->setObjectName("microphoneLayoutLabel2and4");
        microphone2Label = new QLabel(gb_microphone_settings);
        microphone2Label->setObjectName("microphone2Label");
        sizePolicy2.setHeightForWidth(microphone2Label->sizePolicy().hasHeightForWidth());
        microphone2Label->setSizePolicy(sizePolicy2);

        microphoneLayoutLabel2and4->addWidget(microphone2Label);

        microphone4Label = new QLabel(gb_microphone_settings);
        microphone4Label->setObjectName("microphone4Label");
        sizePolicy2.setHeightForWidth(microphone4Label->sizePolicy().hasHeightForWidth());
        microphone4Label->setSizePolicy(sizePolicy2);

        microphoneLayoutLabel2and4->addWidget(microphone4Label);


        microphoneLayoutBottom->addLayout(microphoneLayoutLabel2and4);

        microphoneLayoutBox2and4 = new QVBoxLayout();
        microphoneLayoutBox2and4->setObjectName("microphoneLayoutBox2and4");
        microphone2Box = new QComboBox(gb_microphone_settings);
        microphone2Box->setObjectName("microphone2Box");
        sizePolicy3.setHeightForWidth(microphone2Box->sizePolicy().hasHeightForWidth());
        microphone2Box->setSizePolicy(sizePolicy3);

        microphoneLayoutBox2and4->addWidget(microphone2Box);

        microphone4Box = new QComboBox(gb_microphone_settings);
        microphone4Box->setObjectName("microphone4Box");
        sizePolicy3.setHeightForWidth(microphone4Box->sizePolicy().hasHeightForWidth());
        microphone4Box->setSizePolicy(sizePolicy3);

        microphoneLayoutBox2and4->addWidget(microphone4Box);


        microphoneLayoutBottom->addLayout(microphoneLayoutBox2and4);


        gb_microphone_settings_layout->addLayout(microphoneLayoutBottom);


        audioTab_layout->addWidget(gb_microphone_settings);

        audioTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        audioTab_layout->addItem(audioTabSpacer);

        gb_description_audio = new QGroupBox(audioTab);
        gb_description_audio->setObjectName("gb_description_audio");
        gb_description_audio_layout = new QVBoxLayout(gb_description_audio);
        gb_description_audio_layout->setObjectName("gb_description_audio_layout");
        description_audio = new QLabel(gb_description_audio);
        description_audio->setObjectName("description_audio");
        description_audio->setTextFormat(Qt::TextFormat::PlainText);
        description_audio->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_audio->setWordWrap(true);

        gb_description_audio_layout->addWidget(description_audio);


        audioTab_layout->addWidget(gb_description_audio);

        audioTab_layout->setStretch(2, 1);
        tab_widget_settings->addTab(audioTab, QString());
        inputTab = new QWidget();
        inputTab->setObjectName("inputTab");
        inputTab_layout = new QVBoxLayout(inputTab);
        inputTab_layout->setObjectName("inputTab_layout");
        ioGridLayout = new QGridLayout();
        ioGridLayout->setObjectName("ioGridLayout");
        gb_ghltar_emulated = new QGroupBox(inputTab);
        gb_ghltar_emulated->setObjectName("gb_ghltar_emulated");
        gb_ghltar_emulated_layout = new QVBoxLayout(gb_ghltar_emulated);
        gb_ghltar_emulated_layout->setObjectName("gb_ghltar_emulated_layout");
        ghltarBox = new QComboBox(gb_ghltar_emulated);
        ghltarBox->setObjectName("ghltarBox");

        gb_ghltar_emulated_layout->addWidget(ghltarBox);


        ioGridLayout->addWidget(gb_ghltar_emulated, 2, 2, 1, 1);

        gb_move_handler = new QGroupBox(inputTab);
        gb_move_handler->setObjectName("gb_move_handler");
        gb_move_handler_layout = new QVBoxLayout(gb_move_handler);
        gb_move_handler_layout->setObjectName("gb_move_handler_layout");
        moveBox = new QComboBox(gb_move_handler);
        moveBox->setObjectName("moveBox");

        gb_move_handler_layout->addWidget(moveBox);


        ioGridLayout->addWidget(gb_move_handler, 2, 0, 1, 1);

        gb_turntable_emulated = new QGroupBox(inputTab);
        gb_turntable_emulated->setObjectName("gb_turntable_emulated");
        gb_turntable_emulated_layout = new QVBoxLayout(gb_turntable_emulated);
        gb_turntable_emulated_layout->setObjectName("gb_turntable_emulated_layout");
        turntableBox = new QComboBox(gb_turntable_emulated);
        turntableBox->setObjectName("turntableBox");

        gb_turntable_emulated_layout->addWidget(turntableBox);


        ioGridLayout->addWidget(gb_turntable_emulated, 1, 2, 1, 1);

        gb_mouse_handler = new QGroupBox(inputTab);
        gb_mouse_handler->setObjectName("gb_mouse_handler");
        gb_mouse_handler_layout = new QVBoxLayout(gb_mouse_handler);
        gb_mouse_handler_layout->setObjectName("gb_mouse_handler_layout");
        mouseHandlerBox = new QComboBox(gb_mouse_handler);
        mouseHandlerBox->setObjectName("mouseHandlerBox");

        gb_mouse_handler_layout->addWidget(mouseHandlerBox);


        ioGridLayout->addWidget(gb_mouse_handler, 1, 0, 1, 1);

        gb_buzz_emulated = new QGroupBox(inputTab);
        gb_buzz_emulated->setObjectName("gb_buzz_emulated");
        gb_buzz_emulated_layout = new QVBoxLayout(gb_buzz_emulated);
        gb_buzz_emulated_layout->setObjectName("gb_buzz_emulated_layout");
        buzzBox = new QComboBox(gb_buzz_emulated);
        buzzBox->setObjectName("buzzBox");

        gb_buzz_emulated_layout->addWidget(buzzBox);


        ioGridLayout->addWidget(gb_buzz_emulated, 0, 2, 1, 1);

        gb_keyboard_handler = new QGroupBox(inputTab);
        gb_keyboard_handler->setObjectName("gb_keyboard_handler");
        gb_keyboard_handler_layout = new QVBoxLayout(gb_keyboard_handler);
        gb_keyboard_handler_layout->setObjectName("gb_keyboard_handler_layout");
        keyboardHandlerBox = new QComboBox(gb_keyboard_handler);
        keyboardHandlerBox->setObjectName("keyboardHandlerBox");

        gb_keyboard_handler_layout->addWidget(keyboardHandlerBox);


        ioGridLayout->addWidget(gb_keyboard_handler, 0, 0, 1, 1);

        gb_pad_mode = new QGroupBox(inputTab);
        gb_pad_mode->setObjectName("gb_pad_mode");
        gb_pad_mode_layout = new QVBoxLayout(gb_pad_mode);
        gb_pad_mode_layout->setObjectName("gb_pad_mode_layout");
        padModeBox = new QComboBox(gb_pad_mode);
        padModeBox->setObjectName("padModeBox");

        gb_pad_mode_layout->addWidget(padModeBox);


        ioGridLayout->addWidget(gb_pad_mode, 3, 0, 1, 1);

        gb_camera_type = new QGroupBox(inputTab);
        gb_camera_type->setObjectName("gb_camera_type");
        gb_camera_type_layout = new QVBoxLayout(gb_camera_type);
        gb_camera_type_layout->setObjectName("gb_camera_type_layout");
        cameraTypeBox = new QComboBox(gb_camera_type);
        cameraTypeBox->setObjectName("cameraTypeBox");

        gb_camera_type_layout->addWidget(cameraTypeBox);


        ioGridLayout->addWidget(gb_camera_type, 0, 1, 1, 1);

        gb_camera_flip = new QGroupBox(inputTab);
        gb_camera_flip->setObjectName("gb_camera_flip");
        gb_camera_flip_layout = new QVBoxLayout(gb_camera_flip);
        gb_camera_flip_layout->setObjectName("gb_camera_flip_layout");
        cameraFlipBox = new QComboBox(gb_camera_flip);
        cameraFlipBox->setObjectName("cameraFlipBox");

        gb_camera_flip_layout->addWidget(cameraFlipBox);


        ioGridLayout->addWidget(gb_camera_flip, 3, 1, 1, 1);

        gb_camera_id = new QGroupBox(inputTab);
        gb_camera_id->setObjectName("gb_camera_id");
        camera_id_layout = new QVBoxLayout(gb_camera_id);
        camera_id_layout->setObjectName("camera_id_layout");
        cameraIdBox = new QComboBox(gb_camera_id);
        cameraIdBox->setObjectName("cameraIdBox");

        camera_id_layout->addWidget(cameraIdBox);


        ioGridLayout->addWidget(gb_camera_id, 2, 1, 1, 1);

        gb_camera_setting = new QGroupBox(inputTab);
        gb_camera_setting->setObjectName("gb_camera_setting");
        gb_camera_setting_layout = new QVBoxLayout(gb_camera_setting);
        gb_camera_setting_layout->setObjectName("gb_camera_setting_layout");
        cameraBox = new QComboBox(gb_camera_setting);
        cameraBox->setObjectName("cameraBox");

        gb_camera_setting_layout->addWidget(cameraBox);


        ioGridLayout->addWidget(gb_camera_setting, 1, 1, 1, 1);

        gb_midi_1 = new QGroupBox(inputTab);
        gb_midi_1->setObjectName("gb_midi_1");
        midLayout1 = new QVBoxLayout(gb_midi_1);
        midLayout1->setObjectName("midLayout1");
        midiHLayout1 = new QHBoxLayout();
        midiHLayout1->setObjectName("midiHLayout1");
        midiTypeBox1 = new QComboBox(gb_midi_1);
        midiTypeBox1->setObjectName("midiTypeBox1");

        midiHLayout1->addWidget(midiTypeBox1);

        midiDeviceBox1 = new QComboBox(gb_midi_1);
        midiDeviceBox1->setObjectName("midiDeviceBox1");

        midiHLayout1->addWidget(midiDeviceBox1);

        midiHLayout1->setStretch(0, 1);
        midiHLayout1->setStretch(1, 2);

        midLayout1->addLayout(midiHLayout1);


        ioGridLayout->addWidget(gb_midi_1, 3, 2, 1, 1);

        gb_midi_3 = new QGroupBox(inputTab);
        gb_midi_3->setObjectName("gb_midi_3");
        midLayout3 = new QVBoxLayout(gb_midi_3);
        midLayout3->setObjectName("midLayout3");
        midiHLayout3 = new QHBoxLayout();
        midiHLayout3->setObjectName("midiHLayout3");
        midiTypeBox3 = new QComboBox(gb_midi_3);
        midiTypeBox3->setObjectName("midiTypeBox3");

        midiHLayout3->addWidget(midiTypeBox3);

        midiDeviceBox3 = new QComboBox(gb_midi_3);
        midiDeviceBox3->setObjectName("midiDeviceBox3");

        midiHLayout3->addWidget(midiDeviceBox3);

        midiHLayout3->setStretch(0, 1);
        midiHLayout3->setStretch(1, 2);

        midLayout3->addLayout(midiHLayout3);


        ioGridLayout->addWidget(gb_midi_3, 5, 2, 1, 1);

        gb_midi_2 = new QGroupBox(inputTab);
        gb_midi_2->setObjectName("gb_midi_2");
        midLayout2 = new QVBoxLayout(gb_midi_2);
        midLayout2->setObjectName("midLayout2");
        midiHLayout2 = new QHBoxLayout();
        midiHLayout2->setObjectName("midiHLayout2");
        midiTypeBox2 = new QComboBox(gb_midi_2);
        midiTypeBox2->setObjectName("midiTypeBox2");

        midiHLayout2->addWidget(midiTypeBox2);

        midiDeviceBox2 = new QComboBox(gb_midi_2);
        midiDeviceBox2->setObjectName("midiDeviceBox2");

        midiHLayout2->addWidget(midiDeviceBox2);

        midiHLayout2->setStretch(0, 1);
        midiHLayout2->setStretch(1, 2);

        midLayout2->addLayout(midiHLayout2);


        ioGridLayout->addWidget(gb_midi_2, 4, 2, 1, 1);

        gb_additional_io_settings = new QGroupBox(inputTab);
        gb_additional_io_settings->setObjectName("gb_additional_io_settings");
        layout_gb_additional_io_settings = new QVBoxLayout(gb_additional_io_settings);
        layout_gb_additional_io_settings->setObjectName("layout_gb_additional_io_settings");
        backgroundInputBox = new QCheckBox(gb_additional_io_settings);
        backgroundInputBox->setObjectName("backgroundInputBox");

        layout_gb_additional_io_settings->addWidget(backgroundInputBox);

        padConnectionBox = new QCheckBox(gb_additional_io_settings);
        padConnectionBox->setObjectName("padConnectionBox");

        layout_gb_additional_io_settings->addWidget(padConnectionBox);

        showMoveCursorBox = new QCheckBox(gb_additional_io_settings);
        showMoveCursorBox->setObjectName("showMoveCursorBox");

        layout_gb_additional_io_settings->addWidget(showMoveCursorBox);

        lockOverlayInputToPlayerOne = new QCheckBox(gb_additional_io_settings);
        lockOverlayInputToPlayerOne->setObjectName("lockOverlayInputToPlayerOne");

        layout_gb_additional_io_settings->addWidget(lockOverlayInputToPlayerOne);

        loadSdlMappings = new QCheckBox(gb_additional_io_settings);
        loadSdlMappings->setObjectName("loadSdlMappings");

        layout_gb_additional_io_settings->addWidget(loadSdlMappings);

        verticalSpacerIoAdditionalSettings = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        layout_gb_additional_io_settings->addItem(verticalSpacerIoAdditionalSettings);


        ioGridLayout->addWidget(gb_additional_io_settings, 4, 0, 2, 1);

        ioGridLayout->setColumnStretch(0, 1);
        ioGridLayout->setColumnStretch(1, 1);
        ioGridLayout->setColumnStretch(2, 1);

        inputTab_layout->addLayout(ioGridLayout);

        inputTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        inputTab_layout->addItem(inputTabSpacer);

        gb_description_io = new QGroupBox(inputTab);
        gb_description_io->setObjectName("gb_description_io");
        gb_description_io_layout = new QVBoxLayout(gb_description_io);
        gb_description_io_layout->setObjectName("gb_description_io_layout");
        description_io = new QLabel(gb_description_io);
        description_io->setObjectName("description_io");
        description_io->setTextFormat(Qt::TextFormat::PlainText);
        description_io->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_io->setWordWrap(true);

        gb_description_io_layout->addWidget(description_io);


        inputTab_layout->addWidget(gb_description_io);

        tab_widget_settings->addTab(inputTab, QString());
        systemTab = new QWidget();
        systemTab->setObjectName("systemTab");
        systemTab_layout = new QVBoxLayout(systemTab);
        systemTab_layout->setObjectName("systemTab_layout");
        systemTabHorizontalLayout = new QHBoxLayout();
        systemTabHorizontalLayout->setObjectName("systemTabHorizontalLayout");
        systemTabLeftLayout = new QVBoxLayout();
        systemTabLeftLayout->setObjectName("systemTabLeftLayout");
        gb_sysLang = new QGroupBox(systemTab);
        gb_sysLang->setObjectName("gb_sysLang");
        gb_sysLang_layout = new QVBoxLayout(gb_sysLang);
        gb_sysLang_layout->setObjectName("gb_sysLang_layout");
        sysLangBox = new QComboBox(gb_sysLang);
        sysLangBox->setObjectName("sysLangBox");

        gb_sysLang_layout->addWidget(sysLangBox);


        systemTabLeftLayout->addWidget(gb_sysLang);

        gb_console_region = new QGroupBox(systemTab);
        gb_console_region->setObjectName("gb_console_region");
        gb_console_region_layout = new QVBoxLayout(gb_console_region);
        gb_console_region_layout->setObjectName("gb_console_region_layout");
        console_region = new QComboBox(gb_console_region);
        console_region->setObjectName("console_region");

        gb_console_region_layout->addWidget(console_region);


        systemTabLeftLayout->addWidget(gb_console_region);

        gb_enterButtonAssignment = new QGroupBox(systemTab);
        gb_enterButtonAssignment->setObjectName("gb_enterButtonAssignment");
        gb_enterButtonAssignment_layout = new QVBoxLayout(gb_enterButtonAssignment);
        gb_enterButtonAssignment_layout->setObjectName("gb_enterButtonAssignment_layout");
        enterButtonAssignCircle = new QRadioButton(gb_enterButtonAssignment);
        enterButtonAssignCircle->setObjectName("enterButtonAssignCircle");
        enterButtonAssignCircle->setText(QString::fromUtf8("Enter with the Circle button"));

        gb_enterButtonAssignment_layout->addWidget(enterButtonAssignCircle);

        enterButtonAssignCross = new QRadioButton(gb_enterButtonAssignment);
        enterButtonAssignCross->setObjectName("enterButtonAssignCross");
        enterButtonAssignCross->setText(QString::fromUtf8("Enter with the Cross button"));

        gb_enterButtonAssignment_layout->addWidget(enterButtonAssignCross);


        systemTabLeftLayout->addWidget(gb_enterButtonAssignment);

        gb_DiskCacheClearing = new QGroupBox(systemTab);
        gb_DiskCacheClearing->setObjectName("gb_DiskCacheClearing");
        gb_DiskCacheClearing_layout = new QVBoxLayout(gb_DiskCacheClearing);
        gb_DiskCacheClearing_layout->setObjectName("gb_DiskCacheClearing_layout");
        enableCacheClearing = new QCheckBox(gb_DiskCacheClearing);
        enableCacheClearing->setObjectName("enableCacheClearing");

        gb_DiskCacheClearing_layout->addWidget(enableCacheClearing);

        maximumCacheSizeLabel = new QLabel(gb_DiskCacheClearing);
        maximumCacheSizeLabel->setObjectName("maximumCacheSizeLabel");

        gb_DiskCacheClearing_layout->addWidget(maximumCacheSizeLabel);

        maximumCacheSize = new QSlider(gb_DiskCacheClearing);
        maximumCacheSize->setObjectName("maximumCacheSize");
        maximumCacheSize->setPageStep(512);
        maximumCacheSize->setOrientation(Qt::Orientation::Horizontal);
        maximumCacheSize->setTickPosition(QSlider::TickPosition::TicksBelow);
        maximumCacheSize->setTickInterval(1024);

        gb_DiskCacheClearing_layout->addWidget(maximumCacheSize);


        systemTabLeftLayout->addWidget(gb_DiskCacheClearing);

        systemTabLeftVerticalSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Expanding);

        systemTabLeftLayout->addItem(systemTabLeftVerticalSpacer);


        systemTabHorizontalLayout->addLayout(systemTabLeftLayout);

        systemTabMiddleLayout = new QVBoxLayout();
        systemTabMiddleLayout->setObjectName("systemTabMiddleLayout");
        gb_keyboardType = new QGroupBox(systemTab);
        gb_keyboardType->setObjectName("gb_keyboardType");
        verticalLayout_keyboardType = new QVBoxLayout(gb_keyboardType);
        verticalLayout_keyboardType->setObjectName("verticalLayout_keyboardType");
        keyboardType = new QComboBox(gb_keyboardType);
        keyboardType->setObjectName("keyboardType");

        verticalLayout_keyboardType->addWidget(keyboardType);


        systemTabMiddleLayout->addWidget(gb_keyboardType);

        gb_dateFormat = new QGroupBox(systemTab);
        gb_dateFormat->setObjectName("gb_dateFormat");
        verticalLayout_dateFormat = new QVBoxLayout(gb_dateFormat);
        verticalLayout_dateFormat->setObjectName("verticalLayout_dateFormat");
        dateFormat = new QComboBox(gb_dateFormat);
        dateFormat->setObjectName("dateFormat");

        verticalLayout_dateFormat->addWidget(dateFormat);


        systemTabMiddleLayout->addWidget(gb_dateFormat);

        gb_timeFormat = new QGroupBox(systemTab);
        gb_timeFormat->setObjectName("gb_timeFormat");
        verticalLayout_timeFormat = new QVBoxLayout(gb_timeFormat);
        verticalLayout_timeFormat->setObjectName("verticalLayout_timeFormat");
        timeFormat = new QComboBox(gb_timeFormat);
        timeFormat->setObjectName("timeFormat");

        verticalLayout_timeFormat->addWidget(timeFormat);


        systemTabMiddleLayout->addWidget(gb_timeFormat);

        gb_console_time = new QGroupBox(systemTab);
        gb_console_time->setObjectName("gb_console_time");
        verticalLayout_2 = new QVBoxLayout(gb_console_time);
        verticalLayout_2->setObjectName("verticalLayout_2");
        horizontalLayout = new QHBoxLayout();
        horizontalLayout->setObjectName("horizontalLayout");
        console_time_edit = new QDateTimeEdit(gb_console_time);
        console_time_edit->setObjectName("console_time_edit");
        QSizePolicy sizePolicy4(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Fixed);
        sizePolicy4.setHorizontalStretch(10);
        sizePolicy4.setVerticalStretch(0);
        sizePolicy4.setHeightForWidth(console_time_edit->sizePolicy().hasHeightForWidth());
        console_time_edit->setSizePolicy(sizePolicy4);
        console_time_edit->setLayoutDirection(Qt::LayoutDirection::LeftToRight);
        console_time_edit->setWrapping(false);
        console_time_edit->setFrame(true);
        console_time_edit->setAlignment(Qt::AlignmentFlag::AlignCenter);
        console_time_edit->setReadOnly(false);
        console_time_edit->setButtonSymbols(QAbstractSpinBox::ButtonSymbols::UpDownArrows);
        console_time_edit->setAccelerated(true);
        console_time_edit->setProperty("showGroupSeparator", QVariant(false));
        console_time_edit->setCalendarPopup(true);

        horizontalLayout->addWidget(console_time_edit);

        console_time_reset = new QPushButton(gb_console_time);
        console_time_reset->setObjectName("console_time_reset");

        horizontalLayout->addWidget(console_time_reset);


        verticalLayout_2->addLayout(horizontalLayout);


        systemTabMiddleLayout->addWidget(gb_console_time);

        systemTabMiddleVerticalSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Expanding);

        systemTabMiddleLayout->addItem(systemTabMiddleVerticalSpacer);


        systemTabHorizontalLayout->addLayout(systemTabMiddleLayout);

        systemTabRightLayout = new QVBoxLayout();
        systemTabRightLayout->setObjectName("systemTabRightLayout");
        gb_homebrew = new QGroupBox(systemTab);
        gb_homebrew->setObjectName("gb_homebrew");
        gb_homebrew_layout = new QVBoxLayout(gb_homebrew);
        gb_homebrew_layout->setObjectName("gb_homebrew_layout");
        enableHostRoot = new QCheckBox(gb_homebrew);
        enableHostRoot->setObjectName("enableHostRoot");

        gb_homebrew_layout->addWidget(enableHostRoot);

        emptyHdd0Tmp = new QCheckBox(gb_homebrew);
        emptyHdd0Tmp->setObjectName("emptyHdd0Tmp");

        gb_homebrew_layout->addWidget(emptyHdd0Tmp);


        systemTabRightLayout->addWidget(gb_homebrew);

        systemTabRightVerticalSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Expanding);

        systemTabRightLayout->addItem(systemTabRightVerticalSpacer);


        systemTabHorizontalLayout->addLayout(systemTabRightLayout);

        systemTabHorizontalLayout->setStretch(0, 1);
        systemTabHorizontalLayout->setStretch(1, 1);
        systemTabHorizontalLayout->setStretch(2, 1);

        systemTab_layout->addLayout(systemTabHorizontalLayout);

        systemTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        systemTab_layout->addItem(systemTabSpacer);

        gb_description_system = new QGroupBox(systemTab);
        gb_description_system->setObjectName("gb_description_system");
        gb_description_system_layout = new QHBoxLayout(gb_description_system);
        gb_description_system_layout->setObjectName("gb_description_system_layout");
        description_system = new QLabel(gb_description_system);
        description_system->setObjectName("description_system");
        description_system->setTextFormat(Qt::TextFormat::PlainText);
        description_system->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_system->setWordWrap(true);

        gb_description_system_layout->addWidget(description_system);


        systemTab_layout->addWidget(gb_description_system);

        systemTab_layout->setStretch(1, 1);
        tab_widget_settings->addTab(systemTab, QString());
        networkTab = new QWidget();
        networkTab->setObjectName("networkTab");
        networkTab_layout = new QVBoxLayout(networkTab);
        networkTab_layout->setObjectName("networkTab_layout");
        networkTabLayout = new QHBoxLayout();
        networkTabLayout->setObjectName("networkTabLayout");
        gb_network_status = new QGroupBox(networkTab);
        gb_network_status->setObjectName("gb_network_status");
        gb_network_status_layout = new QVBoxLayout(gb_network_status);
        gb_network_status_layout->setObjectName("gb_network_status_layout");
        gb_netStatusBox = new QGroupBox(gb_network_status);
        gb_netStatusBox->setObjectName("gb_netStatusBox");
        gb_netStatusBox_layout = new QVBoxLayout(gb_netStatusBox);
        gb_netStatusBox_layout->setObjectName("gb_netStatusBox_layout");
        netStatusBox = new QComboBox(gb_netStatusBox);
        netStatusBox->setObjectName("netStatusBox");

        gb_netStatusBox_layout->addWidget(netStatusBox);


        gb_network_status_layout->addWidget(gb_netStatusBox);

        gb_edit_dns = new QGroupBox(gb_network_status);
        gb_edit_dns->setObjectName("gb_edit_dns");
        gb_edit_dns_layout = new QVBoxLayout(gb_edit_dns);
        gb_edit_dns_layout->setObjectName("gb_edit_dns_layout");
        edit_dns = new QLineEdit(gb_edit_dns);
        edit_dns->setObjectName("edit_dns");
        QSizePolicy sizePolicy5(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Fixed);
        sizePolicy5.setHorizontalStretch(0);
        sizePolicy5.setVerticalStretch(0);
        sizePolicy5.setHeightForWidth(edit_dns->sizePolicy().hasHeightForWidth());
        edit_dns->setSizePolicy(sizePolicy5);

        gb_edit_dns_layout->addWidget(edit_dns);


        gb_network_status_layout->addWidget(gb_edit_dns);

        gb_edit_swaps = new QGroupBox(gb_network_status);
        gb_edit_swaps->setObjectName("gb_edit_swaps");
        gb_edit_swaps_layout = new QVBoxLayout(gb_edit_swaps);
        gb_edit_swaps_layout->setObjectName("gb_edit_swaps_layout");
        edit_swaps = new QLineEdit(gb_edit_swaps);
        edit_swaps->setObjectName("edit_swaps");
        sizePolicy5.setHeightForWidth(edit_swaps->sizePolicy().hasHeightForWidth());
        edit_swaps->setSizePolicy(sizePolicy5);

        gb_edit_swaps_layout->addWidget(edit_swaps);


        gb_network_status_layout->addWidget(gb_edit_swaps);

        gb_edit_bind = new QGroupBox(gb_network_status);
        gb_edit_bind->setObjectName("gb_edit_bind");
        gb_edit_bind_layout = new QVBoxLayout(gb_edit_bind);
        gb_edit_bind_layout->setObjectName("gb_edit_bind_layout");
        edit_bind = new QLineEdit(gb_edit_bind);
        edit_bind->setObjectName("edit_bind");
        sizePolicy5.setHeightForWidth(edit_bind->sizePolicy().hasHeightForWidth());
        edit_bind->setSizePolicy(sizePolicy5);

        gb_edit_bind_layout->addWidget(edit_bind);


        gb_network_status_layout->addWidget(gb_edit_bind);

        enable_upnp = new QCheckBox(gb_network_status);
        enable_upnp->setObjectName("enable_upnp");

        gb_network_status_layout->addWidget(enable_upnp);

        networkTabSpacerLeft = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_network_status_layout->addItem(networkTabSpacerLeft);


        networkTabLayout->addWidget(gb_network_status);

        gb_psn_config = new QGroupBox(networkTab);
        gb_psn_config->setObjectName("gb_psn_config");
        gb_psn_config_layout = new QVBoxLayout(gb_psn_config);
        gb_psn_config_layout->setObjectName("gb_psn_config_layout");
        gb_psnStatusBox = new QGroupBox(gb_psn_config);
        gb_psnStatusBox->setObjectName("gb_psnStatusBox");
        gb_psnStatusBox_layout = new QVBoxLayout(gb_psnStatusBox);
        gb_psnStatusBox_layout->setObjectName("gb_psnStatusBox_layout");
        psnStatusBox = new QComboBox(gb_psnStatusBox);
        psnStatusBox->setObjectName("psnStatusBox");

        gb_psnStatusBox_layout->addWidget(psnStatusBox);


        gb_psn_config_layout->addWidget(gb_psnStatusBox);

        gb_psnCountryBox = new QGroupBox(gb_psn_config);
        gb_psnCountryBox->setObjectName("gb_psnCountryBox");
        gb_psnCountryBox_layout = new QVBoxLayout(gb_psnCountryBox);
        gb_psnCountryBox_layout->setObjectName("gb_psnCountryBox_layout");
        psnCountryBox = new QComboBox(gb_psnCountryBox);
        psnCountryBox->setObjectName("psnCountryBox");

        gb_psnCountryBox_layout->addWidget(psnCountryBox);


        gb_psn_config_layout->addWidget(gb_psnCountryBox);

        enable_clans = new QCheckBox(gb_psn_config);
        enable_clans->setObjectName("enable_clans");

        gb_psn_config_layout->addWidget(enable_clans);

        networkTabSpacerRight = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_psn_config_layout->addItem(networkTabSpacerRight);


        networkTabLayout->addWidget(gb_psn_config);


        networkTab_layout->addLayout(networkTabLayout);

        networkTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        networkTab_layout->addItem(networkTabSpacer);

        gb_description_network = new QGroupBox(networkTab);
        gb_description_network->setObjectName("gb_description_network");
        gb_description_network_layout = new QVBoxLayout(gb_description_network);
        gb_description_network_layout->setObjectName("gb_description_network_layout");
        description_network = new QLabel(gb_description_network);
        description_network->setObjectName("description_network");
        description_network->setTextFormat(Qt::TextFormat::PlainText);
        description_network->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_network->setWordWrap(true);

        gb_description_network_layout->addWidget(description_network);


        networkTab_layout->addWidget(gb_description_network);

        networkTab_layout->setStretch(1, 1);
        tab_widget_settings->addTab(networkTab, QString());
        advancedTab = new QWidget();
        advancedTab->setObjectName("advancedTab");
        advancedTab_layout = new QVBoxLayout(advancedTab);
        advancedTab_layout->setObjectName("advancedTab_layout");
        advancedTabLayout = new QHBoxLayout();
        advancedTabLayout->setObjectName("advancedTabLayout");
        advancedTabLayoutLeft = new QVBoxLayout();
        advancedTabLayoutLeft->setObjectName("advancedTabLayoutLeft");
        gb_advanced_core = new QGroupBox(advancedTab);
        gb_advanced_core->setObjectName("gb_advanced_core");
        sizePolicy1.setHeightForWidth(gb_advanced_core->sizePolicy().hasHeightForWidth());
        gb_advanced_core->setSizePolicy(sizePolicy1);
        gb_advanced_core_layout = new QVBoxLayout(gb_advanced_core);
        gb_advanced_core_layout->setObjectName("gb_advanced_core_layout");
        accurateRSXAccess = new QCheckBox(gb_advanced_core);
        accurateRSXAccess->setObjectName("accurateRSXAccess");

        gb_advanced_core_layout->addWidget(accurateRSXAccess);

        accurateSpuDMA = new QCheckBox(gb_advanced_core);
        accurateSpuDMA->setObjectName("accurateSpuDMA");

        gb_advanced_core_layout->addWidget(accurateSpuDMA);

        antiCheatSavestates = new QCheckBox(gb_advanced_core);
        antiCheatSavestates->setObjectName("antiCheatSavestates");

        gb_advanced_core_layout->addWidget(antiCheatSavestates);

        debugConsoleMode = new QCheckBox(gb_advanced_core);
        debugConsoleMode->setObjectName("debugConsoleMode");

        gb_advanced_core_layout->addWidget(debugConsoleMode);

        mfcDelayCommand = new QCheckBox(gb_advanced_core);
        mfcDelayCommand->setObjectName("mfcDelayCommand");

        gb_advanced_core_layout->addWidget(mfcDelayCommand);

        disableSpinOptimization = new QCheckBox(gb_advanced_core);
        disableSpinOptimization->setObjectName("disableSpinOptimization");

        gb_advanced_core_layout->addWidget(disableSpinOptimization);

        enableSpuEventsBusyLoop = new QCheckBox(gb_advanced_core);
        enableSpuEventsBusyLoop->setObjectName("enableSpuEventsBusyLoop");

        gb_advanced_core_layout->addWidget(enableSpuEventsBusyLoop);

        spuLoopDetection = new QCheckBox(gb_advanced_core);
        spuLoopDetection->setObjectName("spuLoopDetection");

        gb_advanced_core_layout->addWidget(spuLoopDetection);

        llvmPrecompilation = new QCheckBox(gb_advanced_core);
        llvmPrecompilation->setObjectName("llvmPrecompilation");

        gb_advanced_core_layout->addWidget(llvmPrecompilation);

        silenceAllLogs = new QCheckBox(gb_advanced_core);
        silenceAllLogs->setObjectName("silenceAllLogs");

        gb_advanced_core_layout->addWidget(silenceAllLogs);

        compatibleSavestates = new QCheckBox(gb_advanced_core);
        compatibleSavestates->setObjectName("compatibleSavestates");

        gb_advanced_core_layout->addWidget(compatibleSavestates);


        advancedTabLayoutLeft->addWidget(gb_advanced_core);

        gb_sleep_timers_accuracy = new QGroupBox(advancedTab);
        gb_sleep_timers_accuracy->setObjectName("gb_sleep_timers_accuracy");
        sizePolicy1.setHeightForWidth(gb_sleep_timers_accuracy->sizePolicy().hasHeightForWidth());
        gb_sleep_timers_accuracy->setSizePolicy(sizePolicy1);
        gb_sleep_timers_accuracy_layout = new QVBoxLayout(gb_sleep_timers_accuracy);
        gb_sleep_timers_accuracy_layout->setObjectName("gb_sleep_timers_accuracy_layout");
        sleepTimersAccuracy = new QComboBox(gb_sleep_timers_accuracy);
        sleepTimersAccuracy->setObjectName("sleepTimersAccuracy");

        gb_sleep_timers_accuracy_layout->addWidget(sleepTimersAccuracy);


        advancedTabLayoutLeft->addWidget(gb_sleep_timers_accuracy);

        gb_max_spurs_threads = new QGroupBox(advancedTab);
        gb_max_spurs_threads->setObjectName("gb_max_spurs_threads");
        sizePolicy1.setHeightForWidth(gb_max_spurs_threads->sizePolicy().hasHeightForWidth());
        gb_max_spurs_threads->setSizePolicy(sizePolicy1);
        gb_max_spurs_threads_layout = new QVBoxLayout(gb_max_spurs_threads);
        gb_max_spurs_threads_layout->setObjectName("gb_max_spurs_threads_layout");
        maxSPURSThreads = new QComboBox(gb_max_spurs_threads);
        maxSPURSThreads->setObjectName("maxSPURSThreads");

        gb_max_spurs_threads_layout->addWidget(maxSPURSThreads);


        advancedTabLayoutLeft->addWidget(gb_max_spurs_threads);

        gb_clockScale = new QGroupBox(advancedTab);
        gb_clockScale->setObjectName("gb_clockScale");
        sizePolicy1.setHeightForWidth(gb_clockScale->sizePolicy().hasHeightForWidth());
        gb_clockScale->setSizePolicy(sizePolicy1);
        gb_clockScale_layout = new QVBoxLayout(gb_clockScale);
        gb_clockScale_layout->setObjectName("gb_clockScale_layout");
        clockScale = new QSlider(gb_clockScale);
        clockScale->setObjectName("clockScale");
        clockScale->setOrientation(Qt::Orientation::Horizontal);

        gb_clockScale_layout->addWidget(clockScale);

        clockScaleLayout = new QHBoxLayout();
        clockScaleLayout->setObjectName("clockScaleLayout");
        clockScaleText = new QLabel(gb_clockScale);
        clockScaleText->setObjectName("clockScaleText");
        clockScaleText->setAlignment(Qt::AlignmentFlag::AlignCenter);

        clockScaleLayout->addWidget(clockScaleText);

        clockScaleReset = new QPushButton(gb_clockScale);
        clockScaleReset->setObjectName("clockScaleReset");

        clockScaleLayout->addWidget(clockScaleReset);

        clockScaleLayout->setStretch(0, 1);

        gb_clockScale_layout->addLayout(clockScaleLayout);


        advancedTabLayoutLeft->addWidget(gb_clockScale);

        advancedTabSpacerLeft = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        advancedTabLayoutLeft->addItem(advancedTabSpacerLeft);


        advancedTabLayout->addLayout(advancedTabLayoutLeft);

        advancedTabLayoutMiddle = new QVBoxLayout();
        advancedTabLayoutMiddle->setObjectName("advancedTabLayoutMiddle");
        gb_libs = new QGroupBox(advancedTab);
        gb_libs->setObjectName("gb_libs");
        gb_libs_layout = new QVBoxLayout(gb_libs);
        gb_libs_layout->setObjectName("gb_libs_layout");
        hleList = new QListWidget(gb_libs);
        hleList->setObjectName("hleList");
        sizePolicy.setHeightForWidth(hleList->sizePolicy().hasHeightForWidth());
        hleList->setSizePolicy(sizePolicy);
        hleList->setSelectionMode(QAbstractItemView::SelectionMode::ExtendedSelection);

        gb_libs_layout->addWidget(hleList);

        lleList = new QListWidget(gb_libs);
        lleList->setObjectName("lleList");
        sizePolicy.setHeightForWidth(lleList->sizePolicy().hasHeightForWidth());
        lleList->setSizePolicy(sizePolicy);
        lleList->setSelectionMode(QAbstractItemView::SelectionMode::ExtendedSelection);

        gb_libs_layout->addWidget(lleList);

        gb_lleLibs_layout = new QHBoxLayout();
        gb_lleLibs_layout->setSpacing(6);
        gb_lleLibs_layout->setObjectName("gb_lleLibs_layout");
        gb_lleLibs_layout->setSizeConstraint(QLayout::SizeConstraint::SetNoConstraint);
        searchBox = new QLineEdit(gb_libs);
        searchBox->setObjectName("searchBox");

        gb_lleLibs_layout->addWidget(searchBox);

        resetLleList = new QPushButton(gb_libs);
        resetLleList->setObjectName("resetLleList");

        gb_lleLibs_layout->addWidget(resetLleList);

        gb_lleLibs_layout->setStretch(0, 1);

        gb_libs_layout->addLayout(gb_lleLibs_layout);


        advancedTabLayoutMiddle->addWidget(gb_libs);


        advancedTabLayout->addLayout(advancedTabLayoutMiddle);

        advancedTabLayoutRight = new QVBoxLayout();
        advancedTabLayoutRight->setObjectName("advancedTabLayoutRight");
        gb_advanced_gpu = new QGroupBox(advancedTab);
        gb_advanced_gpu->setObjectName("gb_advanced_gpu");
        sizePolicy1.setHeightForWidth(gb_advanced_gpu->sizePolicy().hasHeightForWidth());
        gb_advanced_gpu->setSizePolicy(sizePolicy1);
        gb_advanced_gpu_layout = new QVBoxLayout(gb_advanced_gpu);
        gb_advanced_gpu_layout->setObjectName("gb_advanced_gpu_layout");
        allowHostGPULabels = new QCheckBox(gb_advanced_gpu);
        allowHostGPULabels->setObjectName("allowHostGPULabels");

        gb_advanced_gpu_layout->addWidget(allowHostGPULabels);

        disableMslFastMath = new QCheckBox(gb_advanced_gpu);
        disableMslFastMath->setObjectName("disableMslFastMath");

        gb_advanced_gpu_layout->addWidget(disableMslFastMath);

        disableVertexCache = new QCheckBox(gb_advanced_gpu);
        disableVertexCache->setObjectName("disableVertexCache");

        gb_advanced_gpu_layout->addWidget(disableVertexCache);

        forceHwMSAAResolve = new QCheckBox(gb_advanced_gpu);
        forceHwMSAAResolve->setObjectName("forceHwMSAAResolve");

        gb_advanced_gpu_layout->addWidget(forceHwMSAAResolve);

        handleTiledMemory = new QCheckBox(gb_advanced_gpu);
        handleTiledMemory->setObjectName("handleTiledMemory");

        gb_advanced_gpu_layout->addWidget(handleTiledMemory);

        readDepth = new QCheckBox(gb_advanced_gpu);
        readDepth->setObjectName("readDepth");

        gb_advanced_gpu_layout->addWidget(readDepth);

        readColor = new QCheckBox(gb_advanced_gpu);
        readColor->setObjectName("readColor");

        gb_advanced_gpu_layout->addWidget(readColor);

        useReBAR = new QCheckBox(gb_advanced_gpu);
        useReBAR->setObjectName("useReBAR");

        gb_advanced_gpu_layout->addWidget(useReBAR);

        dumpDepth = new QCheckBox(gb_advanced_gpu);
        dumpDepth->setObjectName("dumpDepth");

        gb_advanced_gpu_layout->addWidget(dumpDepth);


        advancedTabLayoutRight->addWidget(gb_advanced_gpu);

        gb_rsx_fifo_accuracy = new QGroupBox(advancedTab);
        gb_rsx_fifo_accuracy->setObjectName("gb_rsx_fifo_accuracy");
        sizePolicy1.setHeightForWidth(gb_rsx_fifo_accuracy->sizePolicy().hasHeightForWidth());
        gb_rsx_fifo_accuracy->setSizePolicy(sizePolicy1);
        gb_rsx_fifo_accuracy_layout = new QVBoxLayout(gb_rsx_fifo_accuracy);
        gb_rsx_fifo_accuracy_layout->setObjectName("gb_rsx_fifo_accuracy_layout");
        FIFOAccuracy = new QComboBox(gb_rsx_fifo_accuracy);
        FIFOAccuracy->setObjectName("FIFOAccuracy");

        gb_rsx_fifo_accuracy_layout->addWidget(FIFOAccuracy);


        advancedTabLayoutRight->addWidget(gb_rsx_fifo_accuracy);

        gb_exclusiveFullscreen = new QGroupBox(advancedTab);
        gb_exclusiveFullscreen->setObjectName("gb_exclusiveFullscreen");
        sizePolicy1.setHeightForWidth(gb_exclusiveFullscreen->sizePolicy().hasHeightForWidth());
        gb_exclusiveFullscreen->setSizePolicy(sizePolicy1);
        gb_exclusiveFullscreen_layout = new QVBoxLayout(gb_exclusiveFullscreen);
        gb_exclusiveFullscreen_layout->setObjectName("gb_exclusiveFullscreen_layout");
        exclusiveFullscreenMode = new QComboBox(gb_exclusiveFullscreen);
        exclusiveFullscreenMode->setObjectName("exclusiveFullscreenMode");

        gb_exclusiveFullscreen_layout->addWidget(exclusiveFullscreenMode);


        advancedTabLayoutRight->addWidget(gb_exclusiveFullscreen);

        gb_wakeupDelay = new QGroupBox(advancedTab);
        gb_wakeupDelay->setObjectName("gb_wakeupDelay");
        sizePolicy1.setHeightForWidth(gb_wakeupDelay->sizePolicy().hasHeightForWidth());
        gb_wakeupDelay->setSizePolicy(sizePolicy1);
        gb_wakeupDelay_layout = new QVBoxLayout(gb_wakeupDelay);
        gb_wakeupDelay_layout->setObjectName("gb_wakeupDelay_layout");
        wakeupDelay = new QSlider(gb_wakeupDelay);
        wakeupDelay->setObjectName("wakeupDelay");
        wakeupDelay->setOrientation(Qt::Orientation::Horizontal);

        gb_wakeupDelay_layout->addWidget(wakeupDelay);

        wakeupDelayLayout = new QHBoxLayout();
        wakeupDelayLayout->setObjectName("wakeupDelayLayout");
        wakeupText = new QLabel(gb_wakeupDelay);
        wakeupText->setObjectName("wakeupText");
        wakeupText->setAlignment(Qt::AlignmentFlag::AlignCenter);

        wakeupDelayLayout->addWidget(wakeupText);

        wakeupReset = new QPushButton(gb_wakeupDelay);
        wakeupReset->setObjectName("wakeupReset");

        wakeupDelayLayout->addWidget(wakeupReset);

        wakeupDelayLayout->setStretch(0, 1);

        gb_wakeupDelay_layout->addLayout(wakeupDelayLayout);


        advancedTabLayoutRight->addWidget(gb_wakeupDelay);

        gb_vblank = new QGroupBox(advancedTab);
        gb_vblank->setObjectName("gb_vblank");
        sizePolicy1.setHeightForWidth(gb_vblank->sizePolicy().hasHeightForWidth());
        gb_vblank->setSizePolicy(sizePolicy1);
        gb_vblank_layout = new QVBoxLayout(gb_vblank);
        gb_vblank_layout->setObjectName("gb_vblank_layout");
        vblank = new QSlider(gb_vblank);
        vblank->setObjectName("vblank");
        vblank->setOrientation(Qt::Orientation::Horizontal);

        gb_vblank_layout->addWidget(vblank);

        vBlankLayout = new QHBoxLayout();
        vBlankLayout->setObjectName("vBlankLayout");
        vblankText = new QLabel(gb_vblank);
        vblankText->setObjectName("vblankText");
        vblankText->setAlignment(Qt::AlignmentFlag::AlignCenter);

        vBlankLayout->addWidget(vblankText);

        vblankReset = new QPushButton(gb_vblank);
        vblankReset->setObjectName("vblankReset");

        vBlankLayout->addWidget(vblankReset);

        vBlankLayout->setStretch(0, 1);

        gb_vblank_layout->addLayout(vBlankLayout);

        vblankNTSCFixup = new QCheckBox(gb_vblank);
        vblankNTSCFixup->setObjectName("vblankNTSCFixup");

        gb_vblank_layout->addWidget(vblankNTSCFixup);


        advancedTabLayoutRight->addWidget(gb_vblank);

        advancedTabSpacerRight = new QSpacerItem(13, 13, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        advancedTabLayoutRight->addItem(advancedTabSpacerRight);


        advancedTabLayout->addLayout(advancedTabLayoutRight);

        advancedTabLayout->setStretch(0, 1);
        advancedTabLayout->setStretch(1, 1);
        advancedTabLayout->setStretch(2, 1);

        advancedTab_layout->addLayout(advancedTabLayout);

        advancedTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Expanding);

        advancedTab_layout->addItem(advancedTabSpacer);

        gb_description_advanced = new QGroupBox(advancedTab);
        gb_description_advanced->setObjectName("gb_description_advanced");
        gb_description_advanced_layout = new QVBoxLayout(gb_description_advanced);
        gb_description_advanced_layout->setObjectName("gb_description_advanced_layout");
        description_advanced = new QLabel(gb_description_advanced);
        description_advanced->setObjectName("description_advanced");
        description_advanced->setTextFormat(Qt::TextFormat::PlainText);
        description_advanced->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_advanced->setWordWrap(true);

        gb_description_advanced_layout->addWidget(description_advanced);


        advancedTab_layout->addWidget(gb_description_advanced);

        advancedTab_layout->setStretch(0, 1);
        tab_widget_settings->addTab(advancedTab, QString());
        emulatorTab = new QWidget();
        emulatorTab->setObjectName("emulatorTab");
        emulatorTab_layout = new QVBoxLayout(emulatorTab);
        emulatorTab_layout->setObjectName("emulatorTab_layout");
        emulatorTabLayout = new QHBoxLayout();
        emulatorTabLayout->setObjectName("emulatorTabLayout");
        emulatorTabLayoutLeft = new QVBoxLayout();
        emulatorTabLayoutLeft->setObjectName("emulatorTabLayoutLeft");
        gb_emu_settings = new QGroupBox(emulatorTab);
        gb_emu_settings->setObjectName("gb_emu_settings");
        gb_emu_settings_layout = new QVBoxLayout(gb_emu_settings);
        gb_emu_settings_layout->setObjectName("gb_emu_settings_layout");
        enableGamemode = new QCheckBox(gb_emu_settings);
        enableGamemode->setObjectName("enableGamemode");

        gb_emu_settings_layout->addWidget(enableGamemode);

        exitOnStop = new QCheckBox(gb_emu_settings);
        exitOnStop->setObjectName("exitOnStop");

        gb_emu_settings_layout->addWidget(exitOnStop);

        pausedSavestates = new QCheckBox(gb_emu_settings);
        pausedSavestates->setObjectName("pausedSavestates");

        gb_emu_settings_layout->addWidget(pausedSavestates);

        pauseDuringHomeMenu = new QCheckBox(gb_emu_settings);
        pauseDuringHomeMenu->setObjectName("pauseDuringHomeMenu");

        gb_emu_settings_layout->addWidget(pauseDuringHomeMenu);

        pauseOnFocusLoss = new QCheckBox(gb_emu_settings);
        pauseOnFocusLoss->setObjectName("pauseOnFocusLoss");

        gb_emu_settings_layout->addWidget(pauseOnFocusLoss);

        preventDisplaySleep = new QCheckBox(gb_emu_settings);
        preventDisplaySleep->setObjectName("preventDisplaySleep");

        gb_emu_settings_layout->addWidget(preventDisplaySleep);

        startGameFullscreen = new QCheckBox(gb_emu_settings);
        startGameFullscreen->setObjectName("startGameFullscreen");

        gb_emu_settings_layout->addWidget(startGameFullscreen);

        useNativeInterface = new QCheckBox(gb_emu_settings);
        useNativeInterface->setObjectName("useNativeInterface");

        gb_emu_settings_layout->addWidget(useNativeInterface);


        emulatorTabLayoutLeft->addWidget(gb_emu_settings);

        gb_overlay_settings = new QGroupBox(emulatorTab);
        gb_overlay_settings->setObjectName("gb_overlay_settings");
        gb_overlay_settings_layout = new QVBoxLayout(gb_overlay_settings);
        gb_overlay_settings_layout->setObjectName("gb_overlay_settings_layout");
        playMusicDuringBoot = new QCheckBox(gb_overlay_settings);
        playMusicDuringBoot->setObjectName("playMusicDuringBoot");

        gb_overlay_settings_layout->addWidget(playMusicDuringBoot);

        recordWithOverlays = new QCheckBox(gb_overlay_settings);
        recordWithOverlays->setObjectName("recordWithOverlays");

        gb_overlay_settings_layout->addWidget(recordWithOverlays);

        showAnalogLimiterToggleHint = new QCheckBox(gb_overlay_settings);
        showAnalogLimiterToggleHint->setObjectName("showAnalogLimiterToggleHint");

        gb_overlay_settings_layout->addWidget(showAnalogLimiterToggleHint);

        showAutosaveAutoloadHint = new QCheckBox(gb_overlay_settings);
        showAutosaveAutoloadHint->setObjectName("showAutosaveAutoloadHint");

        gb_overlay_settings_layout->addWidget(showAutosaveAutoloadHint);

        showCaptureHints = new QCheckBox(gb_overlay_settings);
        showCaptureHints->setObjectName("showCaptureHints");

        gb_overlay_settings_layout->addWidget(showCaptureHints);

        showFatalErrorHints = new QCheckBox(gb_overlay_settings);
        showFatalErrorHints->setObjectName("showFatalErrorHints");

        gb_overlay_settings_layout->addWidget(showFatalErrorHints);

        showMouseAndKeyboardToggleHint = new QCheckBox(gb_overlay_settings);
        showMouseAndKeyboardToggleHint->setObjectName("showMouseAndKeyboardToggleHint");

        gb_overlay_settings_layout->addWidget(showMouseAndKeyboardToggleHint);

        showRpcnPopups = new QCheckBox(gb_overlay_settings);
        showRpcnPopups->setObjectName("showRpcnPopups");

        gb_overlay_settings_layout->addWidget(showRpcnPopups);

        showPressureIntensityToggleHint = new QCheckBox(gb_overlay_settings);
        showPressureIntensityToggleHint->setObjectName("showPressureIntensityToggleHint");

        gb_overlay_settings_layout->addWidget(showPressureIntensityToggleHint);

        showPPUCompilationHint = new QCheckBox(gb_overlay_settings);
        showPPUCompilationHint->setObjectName("showPPUCompilationHint");

        gb_overlay_settings_layout->addWidget(showPPUCompilationHint);

        showShaderCompilationHint = new QCheckBox(gb_overlay_settings);
        showShaderCompilationHint->setObjectName("showShaderCompilationHint");

        gb_overlay_settings_layout->addWidget(showShaderCompilationHint);

        showTrophyPopups = new QCheckBox(gb_overlay_settings);
        showTrophyPopups->setObjectName("showTrophyPopups");

        gb_overlay_settings_layout->addWidget(showTrophyPopups);

        emulatorTabSpacerLeft = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_overlay_settings_layout->addItem(emulatorTabSpacerLeft);


        emulatorTabLayoutLeft->addWidget(gb_overlay_settings);

        gb_max_llvm = new QGroupBox(emulatorTab);
        gb_max_llvm->setObjectName("gb_max_llvm");
        gb_max_llvm_layout = new QVBoxLayout(gb_max_llvm);
        gb_max_llvm_layout->setObjectName("gb_max_llvm_layout");
        maxLLVMThreads = new QComboBox(gb_max_llvm);
        maxLLVMThreads->setObjectName("maxLLVMThreads");

        gb_max_llvm_layout->addWidget(maxLLVMThreads);


        emulatorTabLayoutLeft->addWidget(gb_max_llvm);

        gb_shader_compiler_threads = new QGroupBox(emulatorTab);
        gb_shader_compiler_threads->setObjectName("gb_shader_compiler_threads");
        gb_shader_compiler_threads_layout = new QVBoxLayout(gb_shader_compiler_threads);
        gb_shader_compiler_threads_layout->setObjectName("gb_shader_compiler_threads_layout");
        shaderCompilerThreads = new QComboBox(gb_shader_compiler_threads);
        shaderCompilerThreads->setObjectName("shaderCompilerThreads");

        gb_shader_compiler_threads_layout->addWidget(shaderCompilerThreads);


        emulatorTabLayoutLeft->addWidget(gb_shader_compiler_threads);


        emulatorTabLayout->addLayout(emulatorTabLayoutLeft);

        emulatorTabLayoutMiddle = new QVBoxLayout();
        emulatorTabLayoutMiddle->setObjectName("emulatorTabLayoutMiddle");
        gb_viewport = new QGroupBox(emulatorTab);
        gb_viewport->setObjectName("gb_viewport");
        gb_viewport_layout = new QVBoxLayout(gb_viewport);
        gb_viewport_layout->setObjectName("gb_viewport_layout");
        gs_disableMouse = new QCheckBox(gb_viewport);
        gs_disableMouse->setObjectName("gs_disableMouse");

        gb_viewport_layout->addWidget(gs_disableMouse);

        gs_disableKbHotkeys = new QCheckBox(gb_viewport);
        gs_disableKbHotkeys->setObjectName("gs_disableKbHotkeys");

        gb_viewport_layout->addWidget(gs_disableKbHotkeys);

        gs_showMouseInFullscreen = new QCheckBox(gb_viewport);
        gs_showMouseInFullscreen->setObjectName("gs_showMouseInFullscreen");

        gb_viewport_layout->addWidget(gs_showMouseInFullscreen);

        gs_lockMouseInFullscreen = new QCheckBox(gb_viewport);
        gs_lockMouseInFullscreen->setObjectName("gs_lockMouseInFullscreen");

        gb_viewport_layout->addWidget(gs_lockMouseInFullscreen);

        gs_hideMouseOnIdle_widget = new QWidget(gb_viewport);
        gs_hideMouseOnIdle_widget->setObjectName("gs_hideMouseOnIdle_widget");
        gs_hideMouseOnIdle_layout = new QHBoxLayout(gs_hideMouseOnIdle_widget);
        gs_hideMouseOnIdle_layout->setObjectName("gs_hideMouseOnIdle_layout");
        gs_hideMouseOnIdle_layout->setContentsMargins(0, 0, 0, 0);
        gs_hideMouseOnIdle = new QCheckBox(gs_hideMouseOnIdle_widget);
        gs_hideMouseOnIdle->setObjectName("gs_hideMouseOnIdle");

        gs_hideMouseOnIdle_layout->addWidget(gs_hideMouseOnIdle);

        gs_hideMouseOnIdleTime = new QSpinBox(gs_hideMouseOnIdle_widget);
        gs_hideMouseOnIdleTime->setObjectName("gs_hideMouseOnIdleTime");
        gs_hideMouseOnIdleTime->setAccelerated(true);
        gs_hideMouseOnIdleTime->setCorrectionMode(QAbstractSpinBox::CorrectionMode::CorrectToNearestValue);
        gs_hideMouseOnIdleTime->setKeyboardTracking(false);
        gs_hideMouseOnIdleTime->setMinimum(200);
        gs_hideMouseOnIdleTime->setMaximum(99999);
        gs_hideMouseOnIdleTime->setStepType(QAbstractSpinBox::StepType::DefaultStepType);
        gs_hideMouseOnIdleTime->setValue(2000);

        gs_hideMouseOnIdle_layout->addWidget(gs_hideMouseOnIdleTime);


        gb_viewport_layout->addWidget(gs_hideMouseOnIdle_widget);

        gs_resizeOnBoot_widget = new QWidget(gb_viewport);
        gs_resizeOnBoot_widget->setObjectName("gs_resizeOnBoot_widget");
        gs_resizeOnBoot_layout = new QVBoxLayout(gs_resizeOnBoot_widget);
        gs_resizeOnBoot_layout->setObjectName("gs_resizeOnBoot_layout");
        gs_resizeOnBoot_layout->setContentsMargins(0, 0, 0, 0);
        gs_resizeOnBoot = new QCheckBox(gs_resizeOnBoot_widget);
        gs_resizeOnBoot->setObjectName("gs_resizeOnBoot");

        gs_resizeOnBoot_layout->addWidget(gs_resizeOnBoot);

        gs_resizeOnBootManual = new QCheckBox(gs_resizeOnBoot_widget);
        gs_resizeOnBootManual->setObjectName("gs_resizeOnBootManual");

        gs_resizeOnBoot_layout->addWidget(gs_resizeOnBootManual);

        gs_resolution_layout = new QHBoxLayout();
        gs_resolution_layout->setObjectName("gs_resolution_layout");
        gb_gs_width = new QGroupBox(gs_resizeOnBoot_widget);
        gb_gs_width->setObjectName("gb_gs_width");
        gb_gs_width_layout = new QVBoxLayout(gb_gs_width);
        gb_gs_width_layout->setObjectName("gb_gs_width_layout");
        gs_width = new QSpinBox(gb_gs_width);
        gs_width->setObjectName("gs_width");
        gs_width->setAccelerated(true);
        gs_width->setCorrectionMode(QAbstractSpinBox::CorrectionMode::CorrectToNearestValue);
        gs_width->setKeyboardTracking(false);
        gs_width->setMinimum(0);
        gs_width->setMaximum(9999);
        gs_width->setValue(0);

        gb_gs_width_layout->addWidget(gs_width);


        gs_resolution_layout->addWidget(gb_gs_width);

        gb_gs_height = new QGroupBox(gs_resizeOnBoot_widget);
        gb_gs_height->setObjectName("gb_gs_height");
        gb_gs_height_layout = new QVBoxLayout(gb_gs_height);
        gb_gs_height_layout->setObjectName("gb_gs_height_layout");
        gs_height = new QSpinBox(gb_gs_height);
        gs_height->setObjectName("gs_height");
        gs_height->setFrame(true);
        gs_height->setAccelerated(true);
        gs_height->setCorrectionMode(QAbstractSpinBox::CorrectionMode::CorrectToNearestValue);
        gs_height->setKeyboardTracking(false);
        gs_height->setMinimum(0);
        gs_height->setMaximum(9999);
        gs_height->setValue(0);

        gb_gs_height_layout->addWidget(gs_height);


        gs_resolution_layout->addWidget(gb_gs_height);


        gs_resizeOnBoot_layout->addLayout(gs_resolution_layout);


        gb_viewport_layout->addWidget(gs_resizeOnBoot_widget);


        emulatorTabLayoutMiddle->addWidget(gb_viewport);

        gb_shader_load = new QGroupBox(emulatorTab);
        gb_shader_load->setObjectName("gb_shader_load");
        gb_shader_load_layout = new QVBoxLayout(gb_shader_load);
        gb_shader_load_layout->setObjectName("gb_shader_load_layout");
        shaderLoadBgEnabled = new QCheckBox(gb_shader_load);
        shaderLoadBgEnabled->setObjectName("shaderLoadBgEnabled");

        gb_shader_load_layout->addWidget(shaderLoadBgEnabled);

        label_shaderLoadBgDarkening = new QLabel(gb_shader_load);
        label_shaderLoadBgDarkening->setObjectName("label_shaderLoadBgDarkening");

        gb_shader_load_layout->addWidget(label_shaderLoadBgDarkening);

        shaderLoadBgDarkening = new QSlider(gb_shader_load);
        shaderLoadBgDarkening->setObjectName("shaderLoadBgDarkening");
        shaderLoadBgDarkening->setOrientation(Qt::Orientation::Horizontal);

        gb_shader_load_layout->addWidget(shaderLoadBgDarkening);

        label_shaderLoadBgBlur = new QLabel(gb_shader_load);
        label_shaderLoadBgBlur->setObjectName("label_shaderLoadBgBlur");

        gb_shader_load_layout->addWidget(label_shaderLoadBgBlur);

        shaderLoadBgBlur = new QSlider(gb_shader_load);
        shaderLoadBgBlur->setObjectName("shaderLoadBgBlur");
        shaderLoadBgBlur->setOrientation(Qt::Orientation::Horizontal);

        gb_shader_load_layout->addWidget(shaderLoadBgBlur);

        spacer_shader_load = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_shader_load_layout->addItem(spacer_shader_load);


        emulatorTabLayoutMiddle->addWidget(gb_shader_load);

        gb_game_window_title = new QGroupBox(emulatorTab);
        gb_game_window_title->setObjectName("gb_game_window_title");
        layout_gb_game_window_title = new QVBoxLayout(gb_game_window_title);
        layout_gb_game_window_title->setObjectName("layout_gb_game_window_title");
        label_game_window_title_format = new QLabel(gb_game_window_title);
        label_game_window_title_format->setObjectName("label_game_window_title_format");
        label_game_window_title_format->setText(QString::fromUtf8("FPS: 60 | Renderer | Version | Game [ID]"));
        label_game_window_title_format->setAlignment(Qt::AlignmentFlag::AlignCenter);

        layout_gb_game_window_title->addWidget(label_game_window_title_format);

        layout_buttons_game_window_title = new QHBoxLayout();
        layout_buttons_game_window_title->setObjectName("layout_buttons_game_window_title");
        reset_button_game_window_title_format = new QPushButton(gb_game_window_title);
        reset_button_game_window_title_format->setObjectName("reset_button_game_window_title_format");

        layout_buttons_game_window_title->addWidget(reset_button_game_window_title_format);

        edit_button_game_window_title_format = new QPushButton(gb_game_window_title);
        edit_button_game_window_title_format->setObjectName("edit_button_game_window_title_format");

        layout_buttons_game_window_title->addWidget(edit_button_game_window_title_format);


        layout_gb_game_window_title->addLayout(layout_buttons_game_window_title);


        emulatorTabLayoutMiddle->addWidget(gb_game_window_title);


        emulatorTabLayout->addLayout(emulatorTabLayoutMiddle);

        emulatorTabLayoutRight = new QVBoxLayout();
        emulatorTabLayoutRight->setObjectName("emulatorTabLayoutRight");
        gb_performance_overlay = new QGroupBox(emulatorTab);
        gb_performance_overlay->setObjectName("gb_performance_overlay");
        gb_performance_overlay_layout = new QVBoxLayout(gb_performance_overlay);
        gb_performance_overlay_layout->setObjectName("gb_performance_overlay_layout");
        perfOverlayEnabled = new QCheckBox(gb_performance_overlay);
        perfOverlayEnabled->setObjectName("perfOverlayEnabled");

        gb_performance_overlay_layout->addWidget(perfOverlayEnabled);

        perfOverlayFramerateGraphEnabled = new QCheckBox(gb_performance_overlay);
        perfOverlayFramerateGraphEnabled->setObjectName("perfOverlayFramerateGraphEnabled");

        gb_performance_overlay_layout->addWidget(perfOverlayFramerateGraphEnabled);

        perfOverlayFrametimeGraphEnabled = new QCheckBox(gb_performance_overlay);
        perfOverlayFrametimeGraphEnabled->setObjectName("perfOverlayFrametimeGraphEnabled");

        gb_performance_overlay_layout->addWidget(perfOverlayFrametimeGraphEnabled);

        perf_overlay_detail_level = new QWidget(gb_performance_overlay);
        perf_overlay_detail_level->setObjectName("perf_overlay_detail_level");
        layout_perf_overlay_detail_level = new QVBoxLayout(perf_overlay_detail_level);
        layout_perf_overlay_detail_level->setObjectName("layout_perf_overlay_detail_level");
        layout_perf_overlay_detail_level->setContentsMargins(0, 0, 0, 0);
        label_detail_level = new QLabel(perf_overlay_detail_level);
        label_detail_level->setObjectName("label_detail_level");

        layout_perf_overlay_detail_level->addWidget(label_detail_level);

        perfOverlayDetailLevel = new QComboBox(perf_overlay_detail_level);
        perfOverlayDetailLevel->setObjectName("perfOverlayDetailLevel");

        layout_perf_overlay_detail_level->addWidget(perfOverlayDetailLevel);


        gb_performance_overlay_layout->addWidget(perf_overlay_detail_level);

        perf_overlay_position = new QWidget(gb_performance_overlay);
        perf_overlay_position->setObjectName("perf_overlay_position");
        layout_perf_overlay_position = new QVBoxLayout(perf_overlay_position);
        layout_perf_overlay_position->setObjectName("layout_perf_overlay_position");
        layout_perf_overlay_position->setContentsMargins(0, 0, 0, 0);
        label_position = new QLabel(perf_overlay_position);
        label_position->setObjectName("label_position");

        layout_perf_overlay_position->addWidget(label_position);

        perfOverlayPosition = new QComboBox(perf_overlay_position);
        perfOverlayPosition->setObjectName("perfOverlayPosition");

        layout_perf_overlay_position->addWidget(perfOverlayPosition);


        gb_performance_overlay_layout->addWidget(perf_overlay_position);

        label_margin_x = new QLabel(gb_performance_overlay);
        label_margin_x->setObjectName("label_margin_x");

        gb_performance_overlay_layout->addWidget(label_margin_x);

        layout_margin_x = new QHBoxLayout();
        layout_margin_x->setObjectName("layout_margin_x");
        perfOverlayCenterX = new QCheckBox(gb_performance_overlay);
        perfOverlayCenterX->setObjectName("perfOverlayCenterX");

        layout_margin_x->addWidget(perfOverlayCenterX);

        perfOverlayMarginX = new QDoubleSpinBox(gb_performance_overlay);
        perfOverlayMarginX->setObjectName("perfOverlayMarginX");
        perfOverlayMarginX->setDecimals(1);
        perfOverlayMarginX->setSingleStep(0.500000000000000);

        layout_margin_x->addWidget(perfOverlayMarginX);


        gb_performance_overlay_layout->addLayout(layout_margin_x);

        label_margin_y = new QLabel(gb_performance_overlay);
        label_margin_y->setObjectName("label_margin_y");

        gb_performance_overlay_layout->addWidget(label_margin_y);

        layout_margin_y = new QHBoxLayout();
        layout_margin_y->setObjectName("layout_margin_y");
        perfOverlayCenterY = new QCheckBox(gb_performance_overlay);
        perfOverlayCenterY->setObjectName("perfOverlayCenterY");

        layout_margin_y->addWidget(perfOverlayCenterY);

        perfOverlayMarginY = new QDoubleSpinBox(gb_performance_overlay);
        perfOverlayMarginY->setObjectName("perfOverlayMarginY");
        perfOverlayMarginY->setDecimals(1);
        perfOverlayMarginY->setSingleStep(0.500000000000000);

        layout_margin_y->addWidget(perfOverlayMarginY);


        gb_performance_overlay_layout->addLayout(layout_margin_y);

        perfOverlayUseWindowSpace = new QCheckBox(gb_performance_overlay);
        perfOverlayUseWindowSpace->setObjectName("perfOverlayUseWindowSpace");

        gb_performance_overlay_layout->addWidget(perfOverlayUseWindowSpace);

        perf_overlay_update_interval = new QWidget(gb_performance_overlay);
        perf_overlay_update_interval->setObjectName("perf_overlay_update_interval");
        layout_perf_overlay_update_interval = new QVBoxLayout(perf_overlay_update_interval);
        layout_perf_overlay_update_interval->setObjectName("layout_perf_overlay_update_interval");
        layout_perf_overlay_update_interval->setContentsMargins(0, 0, 0, 0);
        label_update_interval = new QLabel(perf_overlay_update_interval);
        label_update_interval->setObjectName("label_update_interval");

        layout_perf_overlay_update_interval->addWidget(label_update_interval);

        perfOverlayUpdateInterval = new QSlider(perf_overlay_update_interval);
        perfOverlayUpdateInterval->setObjectName("perfOverlayUpdateInterval");
        perfOverlayUpdateInterval->setSingleStep(10);
        perfOverlayUpdateInterval->setPageStep(100);
        perfOverlayUpdateInterval->setOrientation(Qt::Orientation::Horizontal);

        layout_perf_overlay_update_interval->addWidget(perfOverlayUpdateInterval);


        gb_performance_overlay_layout->addWidget(perf_overlay_update_interval);

        perf_overlay_font_size = new QWidget(gb_performance_overlay);
        perf_overlay_font_size->setObjectName("perf_overlay_font_size");
        layout_perf_overlay_font_size = new QVBoxLayout(perf_overlay_font_size);
        layout_perf_overlay_font_size->setObjectName("layout_perf_overlay_font_size");
        layout_perf_overlay_font_size->setContentsMargins(0, 0, 0, 0);
        label_font_size = new QLabel(perf_overlay_font_size);
        label_font_size->setObjectName("label_font_size");

        layout_perf_overlay_font_size->addWidget(label_font_size);

        perfOverlayFontSize = new QSlider(perf_overlay_font_size);
        perfOverlayFontSize->setObjectName("perfOverlayFontSize");
        perfOverlayFontSize->setOrientation(Qt::Orientation::Horizontal);

        layout_perf_overlay_font_size->addWidget(perfOverlayFontSize);


        gb_performance_overlay_layout->addWidget(perf_overlay_font_size);

        perf_overlay_opacity = new QWidget(gb_performance_overlay);
        perf_overlay_opacity->setObjectName("perf_overlay_opacity");
        layout_perf_overlay_opacity = new QVBoxLayout(perf_overlay_opacity);
        layout_perf_overlay_opacity->setObjectName("layout_perf_overlay_opacity");
        layout_perf_overlay_opacity->setContentsMargins(0, 0, 0, 0);
        label_opacity = new QLabel(perf_overlay_opacity);
        label_opacity->setObjectName("label_opacity");

        layout_perf_overlay_opacity->addWidget(label_opacity);

        perfOverlayOpacity = new QSlider(perf_overlay_opacity);
        perfOverlayOpacity->setObjectName("perfOverlayOpacity");
        perfOverlayOpacity->setOrientation(Qt::Orientation::Horizontal);

        layout_perf_overlay_opacity->addWidget(perfOverlayOpacity);


        gb_performance_overlay_layout->addWidget(perf_overlay_opacity);

        perf_overlay_framerate_datapoints = new QWidget(gb_performance_overlay);
        perf_overlay_framerate_datapoints->setObjectName("perf_overlay_framerate_datapoints");
        layout_perf_overlay_framerate_datapoints = new QVBoxLayout(perf_overlay_framerate_datapoints);
        layout_perf_overlay_framerate_datapoints->setObjectName("layout_perf_overlay_framerate_datapoints");
        layout_perf_overlay_framerate_datapoints->setContentsMargins(0, 0, -1, 0);
        label_framerate_datapoints = new QLabel(perf_overlay_framerate_datapoints);
        label_framerate_datapoints->setObjectName("label_framerate_datapoints");

        layout_perf_overlay_framerate_datapoints->addWidget(label_framerate_datapoints);

        slider_framerate_datapoints = new QSlider(perf_overlay_framerate_datapoints);
        slider_framerate_datapoints->setObjectName("slider_framerate_datapoints");
        slider_framerate_datapoints->setOrientation(Qt::Orientation::Horizontal);

        layout_perf_overlay_framerate_datapoints->addWidget(slider_framerate_datapoints);


        gb_performance_overlay_layout->addWidget(perf_overlay_framerate_datapoints);

        perf_overlay_frametime_datapoints = new QWidget(gb_performance_overlay);
        perf_overlay_frametime_datapoints->setObjectName("perf_overlay_frametime_datapoints");
        layout_perf_overlay_frametime_datapoints = new QVBoxLayout(perf_overlay_frametime_datapoints);
        layout_perf_overlay_frametime_datapoints->setObjectName("layout_perf_overlay_frametime_datapoints");
        layout_perf_overlay_frametime_datapoints->setContentsMargins(0, 0, -1, 0);
        label_frametime_datapoints = new QLabel(perf_overlay_frametime_datapoints);
        label_frametime_datapoints->setObjectName("label_frametime_datapoints");

        layout_perf_overlay_frametime_datapoints->addWidget(label_frametime_datapoints);

        slider_frametime_datapoints = new QSlider(perf_overlay_frametime_datapoints);
        slider_frametime_datapoints->setObjectName("slider_frametime_datapoints");
        slider_frametime_datapoints->setOrientation(Qt::Orientation::Horizontal);

        layout_perf_overlay_frametime_datapoints->addWidget(slider_frametime_datapoints);


        gb_performance_overlay_layout->addWidget(perf_overlay_frametime_datapoints);

        emulatorTabSpacerRight = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_performance_overlay_layout->addItem(emulatorTabSpacerRight);


        emulatorTabLayoutRight->addWidget(gb_performance_overlay);


        emulatorTabLayout->addLayout(emulatorTabLayoutRight);

        emulatorTabLayout->setStretch(0, 1);
        emulatorTabLayout->setStretch(1, 1);
        emulatorTabLayout->setStretch(2, 1);

        emulatorTab_layout->addLayout(emulatorTabLayout);

        emulatorTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        emulatorTab_layout->addItem(emulatorTabSpacer);

        gb_description_emulator = new QGroupBox(emulatorTab);
        gb_description_emulator->setObjectName("gb_description_emulator");
        gb_description_emulator_layout = new QVBoxLayout(gb_description_emulator);
        gb_description_emulator_layout->setObjectName("gb_description_emulator_layout");
        description_emulator = new QLabel(gb_description_emulator);
        description_emulator->setObjectName("description_emulator");
        description_emulator->setTextFormat(Qt::TextFormat::PlainText);
        description_emulator->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_emulator->setWordWrap(true);

        gb_description_emulator_layout->addWidget(description_emulator);


        emulatorTab_layout->addWidget(gb_description_emulator);

        emulatorTab_layout->setStretch(1, 1);
        tab_widget_settings->addTab(emulatorTab, QString());
        guiTab = new QWidget();
        guiTab->setObjectName("guiTab");
        guiTab_layout = new QVBoxLayout(guiTab);
        guiTab_layout->setObjectName("guiTab_layout");
        guiTabLayout = new QHBoxLayout();
        guiTabLayout->setObjectName("guiTabLayout");
        guiTabLayoutLeft = new QVBoxLayout();
        guiTabLayoutLeft->setObjectName("guiTabLayoutLeft");
        gb_stylesheets = new QGroupBox(guiTab);
        gb_stylesheets->setObjectName("gb_stylesheets");
        gb_stylesheets_layout = new QVBoxLayout(gb_stylesheets);
        gb_stylesheets_layout->setObjectName("gb_stylesheets_layout");
        combo_stylesheets = new QComboBox(gb_stylesheets);
        combo_stylesheets->setObjectName("combo_stylesheets");

        gb_stylesheets_layout->addWidget(combo_stylesheets);

        pb_apply_stylesheet = new QPushButton(gb_stylesheets);
        pb_apply_stylesheet->setObjectName("pb_apply_stylesheet");

        gb_stylesheets_layout->addWidget(pb_apply_stylesheet);


        guiTabLayoutLeft->addWidget(gb_stylesheets);

        gb_colors = new QGroupBox(guiTab);
        gb_colors->setObjectName("gb_colors");
        gb_colors_layout = new QVBoxLayout(gb_colors);
        gb_colors_layout->setObjectName("gb_colors_layout");
        gb_colors_layout->setContentsMargins(9, 9, 9, 9);
        cb_custom_colors = new QCheckBox(gb_colors);
        cb_custom_colors->setObjectName("cb_custom_colors");

        gb_colors_layout->addWidget(cb_custom_colors);

        pb_gl_icon_color = new QPushButton(gb_colors);
        pb_gl_icon_color->setObjectName("pb_gl_icon_color");

        gb_colors_layout->addWidget(pb_gl_icon_color);

        pb_sd_icon_color = new QPushButton(gb_colors);
        pb_sd_icon_color->setObjectName("pb_sd_icon_color");

        gb_colors_layout->addWidget(pb_sd_icon_color);

        pb_tr_icon_color = new QPushButton(gb_colors);
        pb_tr_icon_color->setObjectName("pb_tr_icon_color");

        gb_colors_layout->addWidget(pb_tr_icon_color);


        guiTabLayoutLeft->addWidget(gb_colors);

        guiTabSpacerLeft = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        guiTabLayoutLeft->addItem(guiTabSpacerLeft);


        guiTabLayout->addLayout(guiTabLayoutLeft);

        guiTabLayoutMiddle = new QVBoxLayout();
        guiTabLayoutMiddle->setObjectName("guiTabLayoutMiddle");
        gb_log = new QGroupBox(guiTab);
        gb_log->setObjectName("gb_log");
        gb_log_layout = new QVBoxLayout(gb_log);
        gb_log_layout->setObjectName("gb_log_layout");
        log_limit = new QWidget(gb_log);
        log_limit->setObjectName("log_limit");
        QSizePolicy sizePolicy6(QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Minimum);
        sizePolicy6.setHorizontalStretch(0);
        sizePolicy6.setVerticalStretch(0);
        sizePolicy6.setHeightForWidth(log_limit->sizePolicy().hasHeightForWidth());
        log_limit->setSizePolicy(sizePolicy6);
        layout_log_limit = new QVBoxLayout(log_limit);
        layout_log_limit->setObjectName("layout_log_limit");
        layout_log_limit->setContentsMargins(0, 0, 0, 0);
        label_log_limit = new QLabel(log_limit);
        label_log_limit->setObjectName("label_log_limit");

        layout_log_limit->addWidget(label_log_limit);

        spinbox_log_limit = new QSpinBox(log_limit);
        spinbox_log_limit->setObjectName("spinbox_log_limit");
        spinbox_log_limit->setMinimum(0);
        spinbox_log_limit->setMaximum(999999999);

        layout_log_limit->addWidget(spinbox_log_limit);


        gb_log_layout->addWidget(log_limit);

        tty_limit = new QWidget(gb_log);
        tty_limit->setObjectName("tty_limit");
        layout_tty_limit = new QVBoxLayout(tty_limit);
        layout_tty_limit->setObjectName("layout_tty_limit");
        layout_tty_limit->setContentsMargins(0, 0, 0, 0);
        label_tty_limit = new QLabel(tty_limit);
        label_tty_limit->setObjectName("label_tty_limit");

        layout_tty_limit->addWidget(label_tty_limit);

        spinbox_tty_limit = new QSpinBox(tty_limit);
        spinbox_tty_limit->setObjectName("spinbox_tty_limit");
        spinbox_tty_limit->setMaximum(999999999);

        layout_tty_limit->addWidget(spinbox_tty_limit);


        gb_log_layout->addWidget(tty_limit);


        guiTabLayoutMiddle->addWidget(gb_log);

        gb_gui_pad_input = new QGroupBox(guiTab);
        gb_gui_pad_input->setObjectName("gb_gui_pad_input");
        gb_gui_pad_input_layout = new QVBoxLayout(gb_gui_pad_input);
        gb_gui_pad_input_layout->setObjectName("gb_gui_pad_input_layout");
        cb_pad_navigation = new QCheckBox(gb_gui_pad_input);
        cb_pad_navigation->setObjectName("cb_pad_navigation");

        gb_gui_pad_input_layout->addWidget(cb_pad_navigation);

        cb_global_pad_navigation = new QCheckBox(gb_gui_pad_input);
        cb_global_pad_navigation->setObjectName("cb_global_pad_navigation");

        gb_gui_pad_input_layout->addWidget(cb_global_pad_navigation);


        guiTabLayoutMiddle->addWidget(gb_gui_pad_input);

        gb_gui_volume = new QGroupBox(guiTab);
        gb_gui_volume->setObjectName("gb_gui_volume");
        gb_gui_volume_layout = new QVBoxLayout(gb_gui_volume);
        gb_gui_volume_layout->setObjectName("gb_gui_volume_layout");
        gui_volume = new QWidget(gb_gui_volume);
        gui_volume->setObjectName("gui_volume");
        layout_gui_volume = new QVBoxLayout(gui_volume);
        layout_gui_volume->setObjectName("layout_gui_volume");
        layout_gui_volume->setContentsMargins(0, 0, 0, 0);
        guiVolumeLabel = new QLabel(gui_volume);
        guiVolumeLabel->setObjectName("guiVolumeLabel");

        layout_gui_volume->addWidget(guiVolumeLabel);

        guiVolume = new QSlider(gui_volume);
        guiVolume->setObjectName("guiVolume");
        guiVolume->setMaximum(100);
        guiVolume->setOrientation(Qt::Orientation::Horizontal);
        guiVolume->setTickPosition(QSlider::TickPosition::TicksBelow);
        guiVolume->setTickInterval(50);

        layout_gui_volume->addWidget(guiVolume);


        gb_gui_volume_layout->addWidget(gui_volume);


        guiTabLayoutMiddle->addWidget(gb_gui_volume);

        guiTabSpacerMiddle = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        guiTabLayoutMiddle->addItem(guiTabSpacerMiddle);


        guiTabLayout->addLayout(guiTabLayoutMiddle);

        guiTabLayoutRight = new QVBoxLayout();
        guiTabLayoutRight->setObjectName("guiTabLayoutRight");
        gb_gui_options = new QGroupBox(guiTab);
        gb_gui_options->setObjectName("gb_gui_options");
        gb_gui_options_layout = new QVBoxLayout(gb_gui_options);
        gb_gui_options_layout->setObjectName("gb_gui_options_layout");
        cb_show_welcome = new QCheckBox(gb_gui_options);
        cb_show_welcome->setObjectName("cb_show_welcome");

        gb_gui_options_layout->addWidget(cb_show_welcome);

        cb_show_exit_game = new QCheckBox(gb_gui_options);
        cb_show_exit_game->setObjectName("cb_show_exit_game");

        gb_gui_options_layout->addWidget(cb_show_exit_game);

        cb_show_pkg_install = new QCheckBox(gb_gui_options);
        cb_show_pkg_install->setObjectName("cb_show_pkg_install");

        gb_gui_options_layout->addWidget(cb_show_pkg_install);

        cb_show_obsolete_cfg_dialog = new QCheckBox(gb_gui_options);
        cb_show_obsolete_cfg_dialog->setObjectName("cb_show_obsolete_cfg_dialog");

        gb_gui_options_layout->addWidget(cb_show_obsolete_cfg_dialog);

        cb_show_same_buttons_dialog = new QCheckBox(gb_gui_options);
        cb_show_same_buttons_dialog->setObjectName("cb_show_same_buttons_dialog");

        gb_gui_options_layout->addWidget(cb_show_same_buttons_dialog);

        cb_show_restart_hint = new QCheckBox(gb_gui_options);
        cb_show_restart_hint->setObjectName("cb_show_restart_hint");

        gb_gui_options_layout->addWidget(cb_show_restart_hint);

        guiTabSpacerRight = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_gui_options_layout->addItem(guiTabSpacerRight);


        guiTabLayoutRight->addWidget(gb_gui_options);

        gb_updates = new QGroupBox(guiTab);
        gb_updates->setObjectName("gb_updates");
        layout_gb_updates = new QVBoxLayout(gb_updates);
        layout_gb_updates->setObjectName("layout_gb_updates");
        combo_updates = new QComboBox(gb_updates);
        combo_updates->setObjectName("combo_updates");

        layout_gb_updates->addWidget(combo_updates);


        guiTabLayoutRight->addWidget(gb_updates);

        gb_discord = new QGroupBox(guiTab);
        gb_discord->setObjectName("gb_discord");
        gb_discord_layout = new QVBoxLayout(gb_discord);
        gb_discord_layout->setObjectName("gb_discord_layout");
        useRichPresence = new QCheckBox(gb_discord);
        useRichPresence->setObjectName("useRichPresence");

        gb_discord_layout->addWidget(useRichPresence);

        label_discordState = new QLabel(gb_discord);
        label_discordState->setObjectName("label_discordState");

        gb_discord_layout->addWidget(label_discordState);

        discordState = new QLineEdit(gb_discord);
        discordState->setObjectName("discordState");
        QSizePolicy sizePolicy7(QSizePolicy::Policy::MinimumExpanding, QSizePolicy::Policy::Fixed);
        sizePolicy7.setHorizontalStretch(0);
        sizePolicy7.setVerticalStretch(0);
        sizePolicy7.setHeightForWidth(discordState->sizePolicy().hasHeightForWidth());
        discordState->setSizePolicy(sizePolicy7);
        discordState->setMaxLength(128);

        gb_discord_layout->addWidget(discordState);


        guiTabLayoutRight->addWidget(gb_discord);

        gb_uuid = new QGroupBox(guiTab);
        gb_uuid->setObjectName("gb_uuid");
        gb_uuid_layout = new QVBoxLayout(gb_uuid);
        gb_uuid_layout->setObjectName("gb_uuid_layout");
        label_uuid = new QLabel(gb_uuid);
        label_uuid->setObjectName("label_uuid");
        label_uuid->setAlignment(Qt::AlignmentFlag::AlignCenter);

        gb_uuid_layout->addWidget(label_uuid);

        pb_uuid = new QPushButton(gb_uuid);
        pb_uuid->setObjectName("pb_uuid");

        gb_uuid_layout->addWidget(pb_uuid);


        guiTabLayoutRight->addWidget(gb_uuid);


        guiTabLayout->addLayout(guiTabLayoutRight);

        guiTabLayout->setStretch(0, 1);
        guiTabLayout->setStretch(1, 1);
        guiTabLayout->setStretch(2, 1);

        guiTab_layout->addLayout(guiTabLayout);

        guiTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        guiTab_layout->addItem(guiTabSpacer);

        gb_description_gui = new QGroupBox(guiTab);
        gb_description_gui->setObjectName("gb_description_gui");
        gb_description_gui_layout = new QVBoxLayout(gb_description_gui);
        gb_description_gui_layout->setObjectName("gb_description_gui_layout");
        description_gui = new QLabel(gb_description_gui);
        description_gui->setObjectName("description_gui");
        description_gui->setTextFormat(Qt::TextFormat::PlainText);
        description_gui->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_gui->setWordWrap(true);

        gb_description_gui_layout->addWidget(description_gui);


        guiTab_layout->addWidget(gb_description_gui);

        guiTab_layout->setStretch(1, 1);
        tab_widget_settings->addTab(guiTab, QString());
        debugTab = new QWidget();
        debugTab->setObjectName("debugTab");
        debugTab_layout = new QVBoxLayout(debugTab);
        debugTab_layout->setObjectName("debugTab_layout");
        debugTabLayout = new QHBoxLayout();
        debugTabLayout->setObjectName("debugTabLayout");
        gb_debug_gpu = new QGroupBox(debugTab);
        gb_debug_gpu->setObjectName("gb_debug_gpu");
        gb_debug_gpu->setEnabled(true);
        gb_debug_gpu->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        gb_debug_gpu_layout = new QVBoxLayout(gb_debug_gpu);
        gb_debug_gpu_layout->setObjectName("gb_debug_gpu_layout");
        debugOutput = new QCheckBox(gb_debug_gpu);
        debugOutput->setObjectName("debugOutput");

        gb_debug_gpu_layout->addWidget(debugOutput, 0, Qt::AlignmentFlag::AlignTop);

        debugOverlay = new QCheckBox(gb_debug_gpu);
        debugOverlay->setObjectName("debugOverlay");

        gb_debug_gpu_layout->addWidget(debugOverlay);

        disableAsyncHostMM = new QCheckBox(gb_debug_gpu);
        disableAsyncHostMM->setObjectName("disableAsyncHostMM");

        gb_debug_gpu_layout->addWidget(disableAsyncHostMM);

        disableFIFOReordering = new QCheckBox(gb_debug_gpu);
        disableFIFOReordering->setObjectName("disableFIFOReordering");

        gb_debug_gpu_layout->addWidget(disableFIFOReordering);

        disableHardwareTexelRemapping = new QCheckBox(gb_debug_gpu);
        disableHardwareTexelRemapping->setObjectName("disableHardwareTexelRemapping");

        gb_debug_gpu_layout->addWidget(disableHardwareTexelRemapping);

        disableOnDiskShaderCache = new QCheckBox(gb_debug_gpu);
        disableOnDiskShaderCache->setObjectName("disableOnDiskShaderCache");

        gb_debug_gpu_layout->addWidget(disableOnDiskShaderCache);

        disableVideoOutput = new QCheckBox(gb_debug_gpu);
        disableVideoOutput->setObjectName("disableVideoOutput");

        gb_debug_gpu_layout->addWidget(disableVideoOutput);

        disableVulkanMemAllocator = new QCheckBox(gb_debug_gpu);
        disableVulkanMemAllocator->setObjectName("disableVulkanMemAllocator");

        gb_debug_gpu_layout->addWidget(disableVulkanMemAllocator);

        disableHwOcclusionQueries = new QCheckBox(gb_debug_gpu);
        disableHwOcclusionQueries->setObjectName("disableHwOcclusionQueries");

        gb_debug_gpu_layout->addWidget(disableHwOcclusionQueries);

        forceCpuBlitEmulation = new QCheckBox(gb_debug_gpu);
        forceCpuBlitEmulation->setObjectName("forceCpuBlitEmulation");

        gb_debug_gpu_layout->addWidget(forceCpuBlitEmulation);

        gpuTextureScaling = new QCheckBox(gb_debug_gpu);
        gpuTextureScaling->setObjectName("gpuTextureScaling");

        gb_debug_gpu_layout->addWidget(gpuTextureScaling);

        logProg = new QCheckBox(gb_debug_gpu);
        logProg->setObjectName("logProg");

        gb_debug_gpu_layout->addWidget(logProg);

        renderdocCompatibility = new QCheckBox(gb_debug_gpu);
        renderdocCompatibility->setObjectName("renderdocCompatibility");
        renderdocCompatibility->setEnabled(true);

        gb_debug_gpu_layout->addWidget(renderdocCompatibility, 0, Qt::AlignmentFlag::AlignTop);

        strictTextureFlushing = new QCheckBox(gb_debug_gpu);
        strictTextureFlushing->setObjectName("strictTextureFlushing");

        gb_debug_gpu_layout->addWidget(strictTextureFlushing);

        forceHighpZ = new QCheckBox(gb_debug_gpu);
        forceHighpZ->setObjectName("forceHighpZ");

        gb_debug_gpu_layout->addWidget(forceHighpZ, 0, Qt::AlignmentFlag::AlignTop);

        verticalSpacerDebugGPU = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_debug_gpu_layout->addItem(verticalSpacerDebugGPU);


        debugTabLayout->addWidget(gb_debug_gpu);

        gb_debug_core = new QGroupBox(debugTab);
        gb_debug_core->setObjectName("gb_debug_core");
        gb_debug_core_layout = new QVBoxLayout(gb_debug_core);
        gb_debug_core_layout->setObjectName("gb_debug_core_layout");
        alwaysStart = new QCheckBox(gb_debug_core);
        alwaysStart->setObjectName("alwaysStart");

        gb_debug_core_layout->addWidget(alwaysStart);

        perfReport = new QCheckBox(gb_debug_core);
        perfReport->setObjectName("perfReport");

        gb_debug_core_layout->addWidget(perfReport);

        hookStFunc = new QCheckBox(gb_debug_core);
        hookStFunc->setObjectName("hookStFunc");

        gb_debug_core_layout->addWidget(hookStFunc);

        mfcDebug = new QCheckBox(gb_debug_core);
        mfcDebug->setObjectName("mfcDebug");

        gb_debug_core_layout->addWidget(mfcDebug);

        ppuDebug = new QCheckBox(gb_debug_core);
        ppuDebug->setObjectName("ppuDebug");

        gb_debug_core_layout->addWidget(ppuDebug);

        setDAZandFTZ = new QCheckBox(gb_debug_core);
        setDAZandFTZ->setObjectName("setDAZandFTZ");

        gb_debug_core_layout->addWidget(setDAZandFTZ);

        spuDebug = new QCheckBox(gb_debug_core);
        spuDebug->setObjectName("spuDebug");

        gb_debug_core_layout->addWidget(spuDebug);

        spuProfiler = new QCheckBox(gb_debug_core);
        spuProfiler->setObjectName("spuProfiler");

        gb_debug_core_layout->addWidget(spuProfiler);

        verticalSpacerDebugCore = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_debug_core_layout->addItem(verticalSpacerDebugCore);

        gb_debug_cpu = new QGroupBox(gb_debug_core);
        gb_debug_cpu->setObjectName("gb_debug_cpu");
        gb_debug_cpu_layout = new QVBoxLayout(gb_debug_cpu);
        gb_debug_cpu_layout->setObjectName("gb_debug_cpu_layout");
        accurateDFMA = new QCheckBox(gb_debug_cpu);
        accurateDFMA->setObjectName("accurateDFMA");

        gb_debug_cpu_layout->addWidget(accurateDFMA);

        accurateClineStores = new QCheckBox(gb_debug_cpu);
        accurateClineStores->setObjectName("accurateClineStores");

        gb_debug_cpu_layout->addWidget(accurateClineStores);

        accuratePPUFPCC = new QCheckBox(gb_debug_cpu);
        accuratePPUFPCC->setObjectName("accuratePPUFPCC");

        gb_debug_cpu_layout->addWidget(accuratePPUFPCC);

        accuratePPUSAT = new QCheckBox(gb_debug_cpu);
        accuratePPUSAT->setObjectName("accuratePPUSAT");

        gb_debug_cpu_layout->addWidget(accuratePPUSAT);

        accuratePPUNJ = new QCheckBox(gb_debug_cpu);
        accuratePPUNJ->setObjectName("accuratePPUNJ");

        gb_debug_cpu_layout->addWidget(accuratePPUNJ);

        accuratePPUVNAN = new QCheckBox(gb_debug_cpu);
        accuratePPUVNAN->setObjectName("accuratePPUVNAN");

        gb_debug_cpu_layout->addWidget(accuratePPUVNAN);

        ppuNJFixup = new QCheckBox(gb_debug_cpu);
        ppuNJFixup->setObjectName("ppuNJFixup");

        gb_debug_cpu_layout->addWidget(ppuNJFixup);

        PPUVNANfixup = new QCheckBox(gb_debug_cpu);
        PPUVNANfixup->setObjectName("PPUVNANfixup");

        gb_debug_cpu_layout->addWidget(PPUVNANfixup);

        verticalSpacerDebugCpu = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_debug_cpu_layout->addItem(verticalSpacerDebugCpu);


        gb_debug_core_layout->addWidget(gb_debug_cpu);


        debugTabLayout->addWidget(gb_debug_core);

        debug_more_stuff = new QWidget(debugTab);
        debug_more_stuff->setObjectName("debug_more_stuff");
        debug_more_stuff_layout = new QVBoxLayout(debug_more_stuff);
        debug_more_stuff_layout->setObjectName("debug_more_stuff_layout");
        debug_more_stuff_layout->setContentsMargins(0, 0, 0, 0);
        gb_accurate_ppu_128 = new QGroupBox(debug_more_stuff);
        gb_accurate_ppu_128->setObjectName("gb_accurate_ppu_128");
        gb_accurate_ppu_128_layout = new QVBoxLayout(gb_accurate_ppu_128);
        gb_accurate_ppu_128_layout->setObjectName("gb_accurate_ppu_128_layout");
        combo_accurate_ppu_128 = new QComboBox(gb_accurate_ppu_128);
        combo_accurate_ppu_128->setObjectName("combo_accurate_ppu_128");

        gb_accurate_ppu_128_layout->addWidget(combo_accurate_ppu_128);


        debug_more_stuff_layout->addWidget(gb_accurate_ppu_128);

        gb_num_ppu_threads = new QGroupBox(debug_more_stuff);
        gb_num_ppu_threads->setObjectName("gb_num_ppu_threads");
        vbl_num_ppu_threads = new QVBoxLayout(gb_num_ppu_threads);
        vbl_num_ppu_threads->setObjectName("vbl_num_ppu_threads");
        combo_num_ppu_threads = new QComboBox(gb_num_ppu_threads);
        combo_num_ppu_threads->setObjectName("combo_num_ppu_threads");

        vbl_num_ppu_threads->addWidget(combo_num_ppu_threads);


        debug_more_stuff_layout->addWidget(gb_num_ppu_threads);

        gb_Level_of_Detail = new QGroupBox(debug_more_stuff);
        gb_Level_of_Detail->setObjectName("gb_Level_of_Detail");
        gb_Level_of_Detail_Layout = new QVBoxLayout(gb_Level_of_Detail);
        gb_Level_of_Detail_Layout->setObjectName("gb_Level_of_Detail_Layout");
        TextureLODBiasLayout = new QHBoxLayout();
        TextureLODBiasLayout->setObjectName("TextureLODBiasLayout");
        TextureLODBias = new QDoubleSpinBox(gb_Level_of_Detail);
        TextureLODBias->setObjectName("TextureLODBias");

        TextureLODBiasLayout->addWidget(TextureLODBias);

        TextureLODBiasReset = new QPushButton(gb_Level_of_Detail);
        TextureLODBiasReset->setObjectName("TextureLODBiasReset");

        TextureLODBiasLayout->addWidget(TextureLODBiasReset);


        gb_Level_of_Detail_Layout->addLayout(TextureLODBiasLayout);


        debug_more_stuff_layout->addWidget(gb_Level_of_Detail);

        gb_vulkansched = new QGroupBox(debug_more_stuff);
        gb_vulkansched->setObjectName("gb_vulkansched");
        sizePolicy1.setHeightForWidth(gb_vulkansched->sizePolicy().hasHeightForWidth());
        gb_vulkansched->setSizePolicy(sizePolicy1);
        gb_vksched_layout = new QVBoxLayout(gb_vulkansched);
        gb_vksched_layout->setObjectName("gb_vksched_layout");
        vulkansched = new QComboBox(gb_vulkansched);
        vulkansched->setObjectName("vulkansched");

        gb_vksched_layout->addWidget(vulkansched);


        debug_more_stuff_layout->addWidget(gb_vulkansched);

        gb_log_levels = new QGroupBox(debug_more_stuff);
        gb_log_levels->setObjectName("gb_log_levels");
        gb_log_levels_layout = new QVBoxLayout(gb_log_levels);
        gb_log_levels_layout->setObjectName("gb_log_levels_layout");
        pb_log_levels = new QPushButton(gb_log_levels);
        pb_log_levels->setObjectName("pb_log_levels");

        gb_log_levels_layout->addWidget(pb_log_levels);


        debug_more_stuff_layout->addWidget(gb_log_levels);

        gb_debug_io = new QGroupBox(debug_more_stuff);
        gb_debug_io->setObjectName("gb_debug_io");
        gb_debug_io_layout = new QVBoxLayout(gb_debug_io);
        gb_debug_io_layout->setObjectName("gb_debug_io_layout");
        debugOverlayIO = new QCheckBox(gb_debug_io);
        debugOverlayIO->setObjectName("debugOverlayIO");

        gb_debug_io_layout->addWidget(debugOverlayIO);

        debugOverlayMouse = new QCheckBox(gb_debug_io);
        debugOverlayMouse->setObjectName("debugOverlayMouse");

        gb_debug_io_layout->addWidget(debugOverlayMouse);

        verticalSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        gb_debug_io_layout->addItem(verticalSpacer);


        debug_more_stuff_layout->addWidget(gb_debug_io);

        verticalSpacerDebugMore = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        debug_more_stuff_layout->addItem(verticalSpacerDebugMore);

        debug_more_stuff_layout->setStretch(6, 1);

        debugTabLayout->addWidget(debug_more_stuff);

        debugTabLayout->setStretch(0, 1);
        debugTabLayout->setStretch(1, 1);
        debugTabLayout->setStretch(2, 1);

        debugTab_layout->addLayout(debugTabLayout);

        debugTabSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::MinimumExpanding);

        debugTab_layout->addItem(debugTabSpacer);

        gb_description_debug = new QGroupBox(debugTab);
        gb_description_debug->setObjectName("gb_description_debug");
        gb_description_debug_layout = new QVBoxLayout(gb_description_debug);
        gb_description_debug_layout->setObjectName("gb_description_debug_layout");
        description_debug = new QLabel(gb_description_debug);
        description_debug->setObjectName("description_debug");
        description_debug->setTextFormat(Qt::TextFormat::PlainText);
        description_debug->setAlignment(Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop);
        description_debug->setWordWrap(true);

        gb_description_debug_layout->addWidget(description_debug);


        debugTab_layout->addWidget(gb_description_debug);

        debugTab_layout->setStretch(1, 1);
        tab_widget_settings->addTab(debugTab, QString());
        scrollArea->setWidget(tab_widget_settings);

        settings_dialog_layout->addWidget(scrollArea);

        buttonBox = new QDialogButtonBox(settings_dialog);
        buttonBox->setObjectName("buttonBox");
        buttonBox->setStandardButtons(QDialogButtonBox::StandardButton::Apply|QDialogButtonBox::StandardButton::Close|QDialogButtonBox::StandardButton::RestoreDefaults|QDialogButtonBox::StandardButton::Save);

        settings_dialog_layout->addWidget(buttonBox);


        retranslateUi(settings_dialog);

        tab_widget_settings->setCurrentIndex(0);


        QMetaObject::connectSlotsByName(settings_dialog);
    } // setupUi

    void retranslateUi(QDialog *settings_dialog)
    {
        settings_dialog->setWindowTitle(QCoreApplication::translate("settings_dialog", "Settings", nullptr));
        gb_ppu->setTitle(QCoreApplication::translate("settings_dialog", "PPU Decoder", nullptr));
        gb_spu->setTitle(QCoreApplication::translate("settings_dialog", "SPU Decoder", nullptr));
        gb_xfloat_accuracy->setTitle(QCoreApplication::translate("settings_dialog", "SPU XFloat Accuracy", nullptr));
        gb_spuBlockSize->setTitle(QCoreApplication::translate("settings_dialog", "SPU Block Size", nullptr));
        gb_max_preempt_count->setTitle(QCoreApplication::translate("settings_dialog", "Max Power Saving CPU-preemptions", nullptr));
        preemptText->setText(QCoreApplication::translate("settings_dialog", "0", nullptr));
        preemptReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_spu_threads->setTitle(QCoreApplication::translate("settings_dialog", "Preferred SPU Threads", nullptr));
        gb_threadsched->setTitle(QCoreApplication::translate("settings_dialog", "Thread Scheduler", nullptr));
        gb_description_cpu->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_cpu->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(coreTab), QCoreApplication::translate("settings_dialog", "CPU", nullptr));
        gb_renderer->setTitle(QCoreApplication::translate("settings_dialog", "Renderer", nullptr));
        gb_graphicsAdapter->setTitle(QCoreApplication::translate("settings_dialog", "Graphics Device", nullptr));
        gb_aspectRatio->setTitle(QCoreApplication::translate("settings_dialog", "Aspect Ratio", nullptr));
        gb_frameLimit->setTitle(QCoreApplication::translate("settings_dialog", "Framelimit", nullptr));
        gb_anisotropicFilter->setTitle(QCoreApplication::translate("settings_dialog", "Anisotropic Filter", nullptr));
        gb_antiAliasing->setTitle(QCoreApplication::translate("settings_dialog", "Anti-Aliasing (MSAA)", nullptr));
        gbZCULL->setTitle(QCoreApplication::translate("settings_dialog", "ZCULL Accuracy", nullptr));
        gbShaderPrecision->setTitle(QCoreApplication::translate("settings_dialog", "Shader Quality", nullptr));
        gbVsync->setTitle(QCoreApplication::translate("settings_dialog", "Vsync", nullptr));
        gb_stereo->setTitle(QCoreApplication::translate("settings_dialog", "3D", nullptr));
        stereoRenderEnabled->setText(QCoreApplication::translate("settings_dialog", "Enable 3D Support", nullptr));
        gb_screen_size->setTitle(QCoreApplication::translate("settings_dialog", "Screen Size (Inch)", nullptr));
        gb_default_resolution->setTitle(QCoreApplication::translate("settings_dialog", "Default Resolution", nullptr));
        gb_resolutionScale->setTitle(QCoreApplication::translate("settings_dialog", "Resolution Scale (Disable Strict Mode)", nullptr));
        resolutionScaleMin->setText(QCoreApplication::translate("settings_dialog", "25", nullptr));
        resolutionScaleMax->setText(QCoreApplication::translate("settings_dialog", "800", nullptr));
        resolutionScaleVal->setText(QCoreApplication::translate("settings_dialog", "0", nullptr));
        resolutionScaleReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_minimumScalableDimension->setTitle(QCoreApplication::translate("settings_dialog", "Resolution Scale Threshold", nullptr));
        minimumScalableDimensionMin->setText(QCoreApplication::translate("settings_dialog", "1", nullptr));
        minimumScalableDimensionMax->setText(QCoreApplication::translate("settings_dialog", "1024", nullptr));
        minimumScalableDimensionVal->setText(QCoreApplication::translate("settings_dialog", "1x1", nullptr));
        minimumScalableDimensionReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_outputScaling->setTitle(QCoreApplication::translate("settings_dialog", "Output Scaling", nullptr));
        fsrSharpeningStrengthLabel->setText(QCoreApplication::translate("settings_dialog", "RCAS Sharpening Strength", nullptr));
        minSharpeningVal->setText(QCoreApplication::translate("settings_dialog", "0", nullptr));
        maxSharpeningVal->setText(QCoreApplication::translate("settings_dialog", "100", nullptr));
        fsrSharpeningStrengthVal->setText(QCoreApplication::translate("settings_dialog", "0", nullptr));
        fsrSharpeningStrengthReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_shader_mode->setTitle(QCoreApplication::translate("settings_dialog", "Shader Mode", nullptr));
        gb_additional_settings->setTitle(QCoreApplication::translate("settings_dialog", "Additional Settings", nullptr));
        dumpColor->setText(QCoreApplication::translate("settings_dialog", "Write Color Buffers", nullptr));
        strictModeRendering->setText(QCoreApplication::translate("settings_dialog", "Strict Rendering Mode", nullptr));
        stretchToDisplayArea->setText(QCoreApplication::translate("settings_dialog", "Stretch To Display Area", nullptr));
        multithreadedRSX->setText(QCoreApplication::translate("settings_dialog", "Multithreaded RSX", nullptr));
        asyncTextureStreaming->setText(QCoreApplication::translate("settings_dialog", "Asynchronous Texture Streaming", nullptr));
        gb_description_gpu->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_gpu->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(gpuTab), QCoreApplication::translate("settings_dialog", "GPU", nullptr));
        gb_audio_out->setTitle(QCoreApplication::translate("settings_dialog", "Audio Out", nullptr));
        gb_audio_format->setTitle(QCoreApplication::translate("settings_dialog", "Audio Format", nullptr));
        gb_audio_settings->setTitle(QCoreApplication::translate("settings_dialog", "Audio Settings", nullptr));
        convert->setText(QCoreApplication::translate("settings_dialog", "Convert to 16-bit", nullptr));
        audioDump->setText(QCoreApplication::translate("settings_dialog", "Dump to File", nullptr));
        gb_audio_device->setTitle(QCoreApplication::translate("settings_dialog", "Audio Device", nullptr));
        gb_audio_channel_layout->setTitle(QCoreApplication::translate("settings_dialog", "Audio Output Format", nullptr));
        gb_audio_provider->setTitle(QCoreApplication::translate("settings_dialog", "Audio Provider", nullptr));
        gb_audio_avport->setTitle(QCoreApplication::translate("settings_dialog", "RSXAudio Avport", nullptr));
        gb_music_handler->setTitle(QCoreApplication::translate("settings_dialog", "Music Handler", nullptr));
        gb_audio_volume->setTitle(QCoreApplication::translate("settings_dialog", "Volume", nullptr));
        masterVolumeLabel->setText(QCoreApplication::translate("settings_dialog", "Master: 0%", nullptr));
        gb_audio_buffering->setTitle(QCoreApplication::translate("settings_dialog", "Buffering", nullptr));
        enableBuffering->setText(QCoreApplication::translate("settings_dialog", "Enable Buffering", nullptr));
        audioBufferDurationLabel->setText(QCoreApplication::translate("settings_dialog", "Audio Buffer Duration: 0ms", nullptr));
        enableTimeStretching->setText(QCoreApplication::translate("settings_dialog", "Enable Time Stretching", nullptr));
        timeStretchingThresholdLabel->setText(QCoreApplication::translate("settings_dialog", "Time Stretching Threshold: 0%", nullptr));
        gb_microphone_settings->setTitle(QCoreApplication::translate("settings_dialog", "Microphone Settings", nullptr));
        microphoneLabel->setText(QCoreApplication::translate("settings_dialog", "Microphone Type:", nullptr));
        microphone1Label->setText(QCoreApplication::translate("settings_dialog", "Mic1:", nullptr));
        microphone3Label->setText(QCoreApplication::translate("settings_dialog", "Mic3:", nullptr));
        microphone2Label->setText(QCoreApplication::translate("settings_dialog", "Mic2:", nullptr));
        microphone4Label->setText(QCoreApplication::translate("settings_dialog", "Mic4:", nullptr));
        gb_description_audio->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_audio->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(audioTab), QCoreApplication::translate("settings_dialog", "Audio", nullptr));
        gb_ghltar_emulated->setTitle(QCoreApplication::translate("settings_dialog", "Guitar Hero Live Emulated Guitar", nullptr));
        gb_move_handler->setTitle(QCoreApplication::translate("settings_dialog", "Move Handler", nullptr));
        gb_turntable_emulated->setTitle(QCoreApplication::translate("settings_dialog", "DJ Hero Emulated Turntable", nullptr));
        gb_mouse_handler->setTitle(QCoreApplication::translate("settings_dialog", "Mouse Handler", nullptr));
        gb_buzz_emulated->setTitle(QCoreApplication::translate("settings_dialog", "Buzz! Emulated Controller", nullptr));
        gb_keyboard_handler->setTitle(QCoreApplication::translate("settings_dialog", "Keyboard Handler", nullptr));
        gb_pad_mode->setTitle(QCoreApplication::translate("settings_dialog", "Pad Handler Mode", nullptr));
        gb_camera_type->setTitle(QCoreApplication::translate("settings_dialog", "Camera Input", nullptr));
        gb_camera_flip->setTitle(QCoreApplication::translate("settings_dialog", "Camera Flip", nullptr));
        gb_camera_id->setTitle(QCoreApplication::translate("settings_dialog", "Camera", nullptr));
        gb_camera_setting->setTitle(QCoreApplication::translate("settings_dialog", "Camera Handler", nullptr));
        gb_midi_1->setTitle(QCoreApplication::translate("settings_dialog", "Emulated MIDI Device 1", nullptr));
        gb_midi_3->setTitle(QCoreApplication::translate("settings_dialog", "Emulated MIDI Device 3", nullptr));
        gb_midi_2->setTitle(QCoreApplication::translate("settings_dialog", "Emulated MIDI Device 2", nullptr));
        gb_additional_io_settings->setTitle(QCoreApplication::translate("settings_dialog", "Additional Settings", nullptr));
        backgroundInputBox->setText(QCoreApplication::translate("settings_dialog", "Enable Background Input", nullptr));
        padConnectionBox->setText(QCoreApplication::translate("settings_dialog", "Keep Pads Connected", nullptr));
        showMoveCursorBox->setText(QCoreApplication::translate("settings_dialog", "Show PS Move Cursor", nullptr));
        lockOverlayInputToPlayerOne->setText(QCoreApplication::translate("settings_dialog", "Lock Overlay Input To Player One", nullptr));
        loadSdlMappings->setText(QCoreApplication::translate("settings_dialog", "Use SDL GameController Database", nullptr));
        gb_description_io->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_io->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(inputTab), QCoreApplication::translate("settings_dialog", "I/O", nullptr));
        gb_sysLang->setTitle(QCoreApplication::translate("settings_dialog", "Console Language", nullptr));
        gb_console_region->setTitle(QCoreApplication::translate("settings_dialog", "Console Region", nullptr));
        gb_enterButtonAssignment->setTitle(QCoreApplication::translate("settings_dialog", "Enter Button Assignment", nullptr));
        gb_DiskCacheClearing->setTitle(QCoreApplication::translate("settings_dialog", "Disk Cache", nullptr));
        enableCacheClearing->setText(QCoreApplication::translate("settings_dialog", "Clear cache automatically", nullptr));
        maximumCacheSizeLabel->setText(QCoreApplication::translate("settings_dialog", "Cache size: 3072 MB", nullptr));
        gb_keyboardType->setTitle(QCoreApplication::translate("settings_dialog", "Keyboard Type", nullptr));
        gb_dateFormat->setTitle(QCoreApplication::translate("settings_dialog", "Date Format", nullptr));
        gb_timeFormat->setTitle(QCoreApplication::translate("settings_dialog", "Time Format", nullptr));
        gb_console_time->setTitle(QCoreApplication::translate("settings_dialog", "Console Time", nullptr));
        console_time_reset->setText(QCoreApplication::translate("settings_dialog", "Set to Now", nullptr));
        gb_homebrew->setTitle(QCoreApplication::translate("settings_dialog", "Homebrew", nullptr));
        enableHostRoot->setText(QCoreApplication::translate("settings_dialog", "Enable /host_root/", nullptr));
        emptyHdd0Tmp->setText(QCoreApplication::translate("settings_dialog", "Empty /dev_hdd0/tmp/", nullptr));
        gb_description_system->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_system->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(systemTab), QCoreApplication::translate("settings_dialog", "System", nullptr));
        gb_network_status->setTitle(QCoreApplication::translate("settings_dialog", "Network Configuration", nullptr));
        gb_netStatusBox->setTitle(QCoreApplication::translate("settings_dialog", "Network Status", nullptr));
        gb_edit_dns->setTitle(QCoreApplication::translate("settings_dialog", "DNS", nullptr));
        gb_edit_swaps->setTitle(QCoreApplication::translate("settings_dialog", "IP/Hosts switches", nullptr));
        gb_edit_bind->setTitle(QCoreApplication::translate("settings_dialog", "Bind address", nullptr));
        enable_upnp->setText(QCoreApplication::translate("settings_dialog", "Enable UPNP", nullptr));
        gb_psn_config->setTitle(QCoreApplication::translate("settings_dialog", "PSN Configuration", nullptr));
        gb_psnStatusBox->setTitle(QCoreApplication::translate("settings_dialog", "PSN Status", nullptr));
        gb_psnCountryBox->setTitle(QCoreApplication::translate("settings_dialog", "Country", nullptr));
        enable_clans->setText(QCoreApplication::translate("settings_dialog", "Enable Clans", nullptr));
        gb_description_network->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_network->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(networkTab), QCoreApplication::translate("settings_dialog", "Network", nullptr));
        gb_advanced_core->setTitle(QCoreApplication::translate("settings_dialog", "Core", nullptr));
        accurateRSXAccess->setText(QCoreApplication::translate("settings_dialog", "Accurate RSX Reservation Access", nullptr));
        accurateSpuDMA->setText(QCoreApplication::translate("settings_dialog", "Accurate SPU DMA", nullptr));
        antiCheatSavestates->setText(QCoreApplication::translate("settings_dialog", "Anti-Cheat Savestates Mode", nullptr));
        debugConsoleMode->setText(QCoreApplication::translate("settings_dialog", "Debug Console Mode", nullptr));
        mfcDelayCommand->setText(QCoreApplication::translate("settings_dialog", "Delay each odd MFC Command", nullptr));
        disableSpinOptimization->setText(QCoreApplication::translate("settings_dialog", "Disable SPU GETLLAR Spin Optimization", nullptr));
        enableSpuEventsBusyLoop->setText(QCoreApplication::translate("settings_dialog", "Enable SPU Events Busy Loop", nullptr));
        spuLoopDetection->setText(QCoreApplication::translate("settings_dialog", "Enable SPU loop detection", nullptr));
        llvmPrecompilation->setText(QCoreApplication::translate("settings_dialog", "PPU/SPU LLVM Precompilation", nullptr));
        silenceAllLogs->setText(QCoreApplication::translate("settings_dialog", "Silence All Logs", nullptr));
        compatibleSavestates->setText(QCoreApplication::translate("settings_dialog", "SPU Compatible Savestates Mode", nullptr));
        gb_sleep_timers_accuracy->setTitle(QCoreApplication::translate("settings_dialog", "Sleep Timers Accuracy", nullptr));
        gb_max_spurs_threads->setTitle(QCoreApplication::translate("settings_dialog", "Maximum Number of SPURS Threads", nullptr));
        gb_clockScale->setTitle(QCoreApplication::translate("settings_dialog", "Clocks Scale", nullptr));
        clockScaleText->setText(QCoreApplication::translate("settings_dialog", "100%", nullptr));
        clockScaleReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_libs->setTitle(QCoreApplication::translate("settings_dialog", "Firmware Libraries", nullptr));
        resetLleList->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_advanced_gpu->setTitle(QCoreApplication::translate("settings_dialog", "GPU", nullptr));
        allowHostGPULabels->setText(QCoreApplication::translate("settings_dialog", "Allow Host GPU Labels (Experimental)", nullptr));
        disableMslFastMath->setText(QCoreApplication::translate("settings_dialog", "Disable MSL Fast Math", nullptr));
        disableVertexCache->setText(QCoreApplication::translate("settings_dialog", "Disable Vertex Cache", nullptr));
        forceHwMSAAResolve->setText(QCoreApplication::translate("settings_dialog", "Force Hardware MSAA Resolve", nullptr));
        handleTiledMemory->setText(QCoreApplication::translate("settings_dialog", "Handle RSX Memory Tiling", nullptr));
        readDepth->setText(QCoreApplication::translate("settings_dialog", "Read Depth Buffer", nullptr));
        readColor->setText(QCoreApplication::translate("settings_dialog", "Read Color Buffers", nullptr));
        useReBAR->setText(QCoreApplication::translate("settings_dialog", "Use Re-BAR memory for GPU uploads", nullptr));
        dumpDepth->setText(QCoreApplication::translate("settings_dialog", "Write Depth Buffer", nullptr));
        gb_rsx_fifo_accuracy->setTitle(QCoreApplication::translate("settings_dialog", "RSX FIFO Accuracy", nullptr));
        gb_exclusiveFullscreen->setTitle(QCoreApplication::translate("settings_dialog", "Exclusive Fullscreen Mode", nullptr));
        gb_wakeupDelay->setTitle(QCoreApplication::translate("settings_dialog", "Driver Wake-Up Delay", nullptr));
        wakeupText->setText(QCoreApplication::translate("settings_dialog", "1 \302\265s", nullptr));
        wakeupReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_vblank->setTitle(QCoreApplication::translate("settings_dialog", "VBlank Frequency", nullptr));
        vblankText->setText(QCoreApplication::translate("settings_dialog", "60 Hz", nullptr));
        vblankReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        vblankNTSCFixup->setText(QCoreApplication::translate("settings_dialog", "VBlank NTSC Fixup", nullptr));
        gb_description_advanced->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_advanced->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(advancedTab), QCoreApplication::translate("settings_dialog", "Advanced", nullptr));
        gb_emu_settings->setTitle(QCoreApplication::translate("settings_dialog", "Emulator Settings", nullptr));
        enableGamemode->setText(QCoreApplication::translate("settings_dialog", "Enable GameMode", nullptr));
        exitOnStop->setText(QCoreApplication::translate("settings_dialog", "Exit RPCS3 when process finishes", nullptr));
        pausedSavestates->setText(QCoreApplication::translate("settings_dialog", "Pause emulation after loading savestates", nullptr));
        pauseDuringHomeMenu->setText(QCoreApplication::translate("settings_dialog", "Pause emulation during home menu", nullptr));
        pauseOnFocusLoss->setText(QCoreApplication::translate("settings_dialog", "Pause emulation on RPCS3 focus loss", nullptr));
        preventDisplaySleep->setText(QCoreApplication::translate("settings_dialog", "Prevent display sleep while running games", nullptr));
        startGameFullscreen->setText(QCoreApplication::translate("settings_dialog", "Start games in fullscreen mode", nullptr));
        useNativeInterface->setText(QCoreApplication::translate("settings_dialog", "Use native user interface", nullptr));
        gb_overlay_settings->setTitle(QCoreApplication::translate("settings_dialog", "Overlay Settings", nullptr));
        playMusicDuringBoot->setText(QCoreApplication::translate("settings_dialog", "Play music during boot sequence", nullptr));
        recordWithOverlays->setText(QCoreApplication::translate("settings_dialog", "Record and screenshot with overlays", nullptr));
        showAnalogLimiterToggleHint->setText(QCoreApplication::translate("settings_dialog", "Show analog limiter toggle hint", nullptr));
        showAutosaveAutoloadHint->setText(QCoreApplication::translate("settings_dialog", "Show autosave/autoload hint", nullptr));
        showCaptureHints->setText(QCoreApplication::translate("settings_dialog", "Show capture hints", nullptr));
        showFatalErrorHints->setText(QCoreApplication::translate("settings_dialog", "Show fatal error hints", nullptr));
        showMouseAndKeyboardToggleHint->setText(QCoreApplication::translate("settings_dialog", "Show mouse and keyboard toggle hint", nullptr));
        showRpcnPopups->setText(QCoreApplication::translate("settings_dialog", "Show netplay popups", nullptr));
        showPressureIntensityToggleHint->setText(QCoreApplication::translate("settings_dialog", "Show pressure intensity toggle hint", nullptr));
        showPPUCompilationHint->setText(QCoreApplication::translate("settings_dialog", "Show PPU compilation hint", nullptr));
        showShaderCompilationHint->setText(QCoreApplication::translate("settings_dialog", "Show shader compilation hint", nullptr));
        showTrophyPopups->setText(QCoreApplication::translate("settings_dialog", "Show trophy popups", nullptr));
        gb_max_llvm->setTitle(QCoreApplication::translate("settings_dialog", "Max LLVM Compile Threads", nullptr));
        gb_shader_compiler_threads->setTitle(QCoreApplication::translate("settings_dialog", "Max Shader Compile Threads", nullptr));
        gb_viewport->setTitle(QCoreApplication::translate("settings_dialog", "Viewport", nullptr));
        gs_disableMouse->setText(QCoreApplication::translate("settings_dialog", "Ignore doubleclicks for Fullscreen", nullptr));
        gs_disableKbHotkeys->setText(QCoreApplication::translate("settings_dialog", "Ignore keyboard hotkeys", nullptr));
        gs_showMouseInFullscreen->setText(QCoreApplication::translate("settings_dialog", "Show mouse cursor in Fullscreen", nullptr));
        gs_lockMouseInFullscreen->setText(QCoreApplication::translate("settings_dialog", "Lock mouse cursor in Fullscreen", nullptr));
        gs_hideMouseOnIdle->setText(QCoreApplication::translate("settings_dialog", "Hide mouse cursor if idle", nullptr));
        gs_hideMouseOnIdleTime->setSuffix(QCoreApplication::translate("settings_dialog", "ms", nullptr));
        gs_resizeOnBoot->setText(QCoreApplication::translate("settings_dialog", "Resize game window on boot", nullptr));
        gs_resizeOnBootManual->setText(QCoreApplication::translate("settings_dialog", "Resize manually", nullptr));
        gb_gs_width->setTitle(QCoreApplication::translate("settings_dialog", "Width", nullptr));
        gb_gs_height->setTitle(QCoreApplication::translate("settings_dialog", "Height", nullptr));
        gb_shader_load->setTitle(QCoreApplication::translate("settings_dialog", "Shader Loading Screen", nullptr));
        shaderLoadBgEnabled->setText(QCoreApplication::translate("settings_dialog", "Allow custom background", nullptr));
        label_shaderLoadBgDarkening->setText(QCoreApplication::translate("settings_dialog", "Background darkening:", nullptr));
        label_shaderLoadBgBlur->setText(QCoreApplication::translate("settings_dialog", "Background blur:", nullptr));
        gb_game_window_title->setTitle(QCoreApplication::translate("settings_dialog", "Game Window Title", nullptr));
#if QT_CONFIG(tooltip)
        reset_button_game_window_title_format->setToolTip(QCoreApplication::translate("settings_dialog", "Reset the game window title to default", nullptr));
#endif // QT_CONFIG(tooltip)
        reset_button_game_window_title_format->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
#if QT_CONFIG(tooltip)
        edit_button_game_window_title_format->setToolTip(QCoreApplication::translate("settings_dialog", "Edit the game window title", nullptr));
#endif // QT_CONFIG(tooltip)
        edit_button_game_window_title_format->setText(QCoreApplication::translate("settings_dialog", "Edit", nullptr));
        gb_performance_overlay->setTitle(QCoreApplication::translate("settings_dialog", "Performance Overlay", nullptr));
        perfOverlayEnabled->setText(QCoreApplication::translate("settings_dialog", "Enable performance overlay", nullptr));
        perfOverlayFramerateGraphEnabled->setText(QCoreApplication::translate("settings_dialog", "Show framerate graph", nullptr));
        perfOverlayFrametimeGraphEnabled->setText(QCoreApplication::translate("settings_dialog", "Show frametime graph", nullptr));
        label_detail_level->setText(QCoreApplication::translate("settings_dialog", "Detail Level:", nullptr));
        label_position->setText(QCoreApplication::translate("settings_dialog", "Position:", nullptr));
        label_margin_x->setText(QCoreApplication::translate("settings_dialog", "Horizontal Margin:", nullptr));
        perfOverlayCenterX->setText(QCoreApplication::translate("settings_dialog", "Centered", nullptr));
        label_margin_y->setText(QCoreApplication::translate("settings_dialog", "Vertical Margin:", nullptr));
        perfOverlayCenterY->setText(QCoreApplication::translate("settings_dialog", "Centered", nullptr));
        perfOverlayUseWindowSpace->setText(QCoreApplication::translate("settings_dialog", "Use Window Space", nullptr));
        label_update_interval->setText(QCoreApplication::translate("settings_dialog", "Update Interval:", nullptr));
        label_font_size->setText(QCoreApplication::translate("settings_dialog", "Font Size: ", nullptr));
        label_opacity->setText(QCoreApplication::translate("settings_dialog", "Opacity:", nullptr));
        label_framerate_datapoints->setText(QCoreApplication::translate("settings_dialog", "Framerate datapoints:", nullptr));
        label_frametime_datapoints->setText(QCoreApplication::translate("settings_dialog", "Frametime datapoints:", nullptr));
        gb_description_emulator->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_emulator->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(emulatorTab), QCoreApplication::translate("settings_dialog", "Emulator", nullptr));
        gb_stylesheets->setTitle(QCoreApplication::translate("settings_dialog", "UI Stylesheets", nullptr));
        pb_apply_stylesheet->setText(QCoreApplication::translate("settings_dialog", "Apply", nullptr));
        gb_colors->setTitle(QCoreApplication::translate("settings_dialog", "UI Colors", nullptr));
        cb_custom_colors->setText(QCoreApplication::translate("settings_dialog", "Use custom UI Colors", nullptr));
        pb_gl_icon_color->setText(QCoreApplication::translate("settings_dialog", "Gamelist icons", nullptr));
        pb_sd_icon_color->setText(QCoreApplication::translate("settings_dialog", "Save manager icons", nullptr));
        pb_tr_icon_color->setText(QCoreApplication::translate("settings_dialog", "Trophy manager icons", nullptr));
        gb_log->setTitle(QCoreApplication::translate("settings_dialog", "Log", nullptr));
        label_log_limit->setText(QCoreApplication::translate("settings_dialog", "Maximum log blocks (0 = no limit)", nullptr));
        label_tty_limit->setText(QCoreApplication::translate("settings_dialog", "Maximum TTY blocks (0 = no limit)", nullptr));
        gb_gui_pad_input->setTitle(QCoreApplication::translate("settings_dialog", "Pad Input", nullptr));
        cb_pad_navigation->setText(QCoreApplication::translate("settings_dialog", "Enable Pad Navigation", nullptr));
        cb_global_pad_navigation->setText(QCoreApplication::translate("settings_dialog", "Allow Global Pad Navigation", nullptr));
        gb_gui_volume->setTitle(QCoreApplication::translate("settings_dialog", "Volume", nullptr));
        guiVolumeLabel->setText(QCoreApplication::translate("settings_dialog", "GUI: 0%", nullptr));
        gb_gui_options->setTitle(QCoreApplication::translate("settings_dialog", "UI Options", nullptr));
        cb_show_welcome->setText(QCoreApplication::translate("settings_dialog", "Show Welcome Screen", nullptr));
        cb_show_exit_game->setText(QCoreApplication::translate("settings_dialog", "Show Exit Game Confirmation", nullptr));
        cb_show_pkg_install->setText(QCoreApplication::translate("settings_dialog", "Show PKG/PUP Installation Result", nullptr));
        cb_show_obsolete_cfg_dialog->setText(QCoreApplication::translate("settings_dialog", "Show Obsolete Settings Dialog", nullptr));
        cb_show_same_buttons_dialog->setText(QCoreApplication::translate("settings_dialog", "Show Duplicate Buttons Dialog", nullptr));
        cb_show_restart_hint->setText(QCoreApplication::translate("settings_dialog", "Show Restart Dialog", nullptr));
        gb_updates->setTitle(QCoreApplication::translate("settings_dialog", "Check for updates on startup", nullptr));
        gb_discord->setTitle(QCoreApplication::translate("settings_dialog", "Discord", nullptr));
        useRichPresence->setText(QCoreApplication::translate("settings_dialog", "Use Discord Rich Presence", nullptr));
        label_discordState->setText(QCoreApplication::translate("settings_dialog", "Discord Status:", nullptr));
        gb_uuid->setTitle(QCoreApplication::translate("settings_dialog", "Installation ID", nullptr));
        label_uuid->setText(QCoreApplication::translate("settings_dialog", "UUID-placeholder", nullptr));
        pb_uuid->setText(QCoreApplication::translate("settings_dialog", "Create new ID", nullptr));
        gb_description_gui->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_gui->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(guiTab), QCoreApplication::translate("settings_dialog", "GUI", nullptr));
        gb_debug_gpu->setTitle(QCoreApplication::translate("settings_dialog", "GPU", nullptr));
        debugOutput->setText(QCoreApplication::translate("settings_dialog", "Debug Output", nullptr));
        debugOverlay->setText(QCoreApplication::translate("settings_dialog", "Debug Overlay", nullptr));
        disableAsyncHostMM->setText(QCoreApplication::translate("settings_dialog", "Disable Asynchronous Memory Manager", nullptr));
        disableFIFOReordering->setText(QCoreApplication::translate("settings_dialog", "Disable FIFO Reordering", nullptr));
        disableHardwareTexelRemapping->setText(QCoreApplication::translate("settings_dialog", "Disable Hardware ColorSpace Remapping", nullptr));
        disableOnDiskShaderCache->setText(QCoreApplication::translate("settings_dialog", "Disable On-Disk Shader Cache", nullptr));
        disableVideoOutput->setText(QCoreApplication::translate("settings_dialog", "Disable Video Output", nullptr));
        disableVulkanMemAllocator->setText(QCoreApplication::translate("settings_dialog", "Disable Vulkan Memory Allocator", nullptr));
        disableHwOcclusionQueries->setText(QCoreApplication::translate("settings_dialog", "Disable ZCull Occlusion Queries", nullptr));
        forceCpuBlitEmulation->setText(QCoreApplication::translate("settings_dialog", "Force CPU Blit Emulation", nullptr));
        gpuTextureScaling->setText(QCoreApplication::translate("settings_dialog", "Force GPU Texture Scaling", nullptr));
        logProg->setText(QCoreApplication::translate("settings_dialog", "Log Shader Programs", nullptr));
        renderdocCompatibility->setText(QCoreApplication::translate("settings_dialog", "Renderdoc Compatibility Mode", nullptr));
        strictTextureFlushing->setText(QCoreApplication::translate("settings_dialog", "Strict Texture Flushing", nullptr));
        forceHighpZ->setText(QCoreApplication::translate("settings_dialog", "Use High Precision Z-Buffer", nullptr));
        gb_debug_core->setTitle(QCoreApplication::translate("settings_dialog", "Core", nullptr));
        alwaysStart->setText(QCoreApplication::translate("settings_dialog", "Automatically start games after boot", nullptr));
        perfReport->setText(QCoreApplication::translate("settings_dialog", "Enable performance report", nullptr));
        hookStFunc->setText(QCoreApplication::translate("settings_dialog", "Hook static functions", nullptr));
        mfcDebug->setText(QCoreApplication::translate("settings_dialog", "MFC Debug", nullptr));
        ppuDebug->setText(QCoreApplication::translate("settings_dialog", "PPU Debug", nullptr));
        setDAZandFTZ->setText(QCoreApplication::translate("settings_dialog", "PPU Set DAZ and FTZ", nullptr));
        spuDebug->setText(QCoreApplication::translate("settings_dialog", "SPU Debug", nullptr));
        spuProfiler->setText(QCoreApplication::translate("settings_dialog", "SPU Profiler", nullptr));
        gb_debug_cpu->setTitle(QCoreApplication::translate("settings_dialog", "CPU Accuracy", nullptr));
        accurateDFMA->setText(QCoreApplication::translate("settings_dialog", "Accurate PPU/SPU Double-Precision FMA", nullptr));
        accurateClineStores->setText(QCoreApplication::translate("settings_dialog", "Accurate PPU/SPU Cache Line Stores", nullptr));
        accuratePPUFPCC->setText(QCoreApplication::translate("settings_dialog", "Accurate PPU Float Condition Control", nullptr));
        accuratePPUSAT->setText(QCoreApplication::translate("settings_dialog", "Accurate PPU Saturation Bit", nullptr));
        accuratePPUNJ->setText(QCoreApplication::translate("settings_dialog", "Accurate PPU Non-Java Mode", nullptr));
        accuratePPUVNAN->setText(QCoreApplication::translate("settings_dialog", "Accurate PPU Vector NaN Handling", nullptr));
        ppuNJFixup->setText(QCoreApplication::translate("settings_dialog", "Approximate PPU Non-Java Mode", nullptr));
        PPUVNANfixup->setText(QCoreApplication::translate("settings_dialog", "Approximate PPU Vector NaN Handling", nullptr));
        gb_accurate_ppu_128->setTitle(QCoreApplication::translate("settings_dialog", "Accurate PPU 128 Reservations", nullptr));
        gb_num_ppu_threads->setTitle(QCoreApplication::translate("settings_dialog", "PPU Thread Count", nullptr));
        gb_Level_of_Detail->setTitle(QCoreApplication::translate("settings_dialog", "LOD Bias Offset", nullptr));
        TextureLODBiasReset->setText(QCoreApplication::translate("settings_dialog", "Reset", nullptr));
        gb_vulkansched->setTitle(QCoreApplication::translate("settings_dialog", "Vulkan Queue Scheduler", nullptr));
        gb_log_levels->setTitle(QCoreApplication::translate("settings_dialog", "Log Levels", nullptr));
        pb_log_levels->setText(QCoreApplication::translate("settings_dialog", "Configure", nullptr));
        gb_debug_io->setTitle(QCoreApplication::translate("settings_dialog", "I/O", nullptr));
        debugOverlayIO->setText(QCoreApplication::translate("settings_dialog", "Debug Overlay For Pad Input", nullptr));
        debugOverlayMouse->setText(QCoreApplication::translate("settings_dialog", "Debug Overlay For Mouse Input", nullptr));
        gb_description_debug->setTitle(QCoreApplication::translate("settings_dialog", "Description", nullptr));
        description_debug->setText(QCoreApplication::translate("settings_dialog", "Point your mouse at an option to display a description in here.\n"
"\n"
"\n"
"", nullptr));
        tab_widget_settings->setTabText(tab_widget_settings->indexOf(debugTab), QCoreApplication::translate("settings_dialog", "Debug", nullptr));
    } // retranslateUi

};

namespace Ui {
    class settings_dialog: public Ui_settings_dialog {};
} // namespace Ui

QT_END_NAMESPACE

#endif // UI_SETTINGS_DIALOG_H
