diff --git a/Source/Horizon-OC-Monitor/source/sysclk_ipc.c b/Source/Horizon-OC-Monitor/source/sysclk_ipc.c
index ed3fa55f..30508523 100644
--- a/Source/Horizon-OC-Monitor/source/sysclk_ipc.c
+++ b/Source/Horizon-OC-Monitor/source/sysclk_ipc.c
@@ -153,12 +153,6 @@ Result sysclkIpcGetFreqList(SysClkModule module, u32* list, u32 maxCount, u32* o
     );
 }
 
-Result sysclkIpcSetReverseNXRTMode(ReverseNXMode mode)
-{
-    return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetReverseNXRTMode, mode);
-}
-
-
 Result hocClkIpcSetKipData()
 {
     u32 temp = 0;
diff --git a/Source/sys-clk/common/include/sysclk/board.h b/Source/sys-clk/common/include/sysclk/board.h
index cda69da7..46bd9b1f 100644
--- a/Source/sys-clk/common/include/sysclk/board.h
+++ b/Source/sys-clk/common/include/sysclk/board.h
@@ -108,16 +108,6 @@ typedef enum
     SysClkPartLoad_EnumMax
 } SysClkPartLoad;
 
-
-typedef enum
-{
-    ReverseNX_NotFound = 0,
-    ReverseNX_SystemDefault = 0,
-    ReverseNX_Handheld,
-    ReverseNX_Docked,
-} ReverseNXMode;
-
-
 typedef enum {
     HorizonOCSpeedo_CPU = 0,
     HorizonOCSpeedo_GPU,
diff --git a/Source/sys-clk/common/include/sysclk/client/ipc.h b/Source/sys-clk/common/include/sysclk/client/ipc.h
index f0a2419b..9af14a79 100644
--- a/Source/sys-clk/common/include/sysclk/client/ipc.h
+++ b/Source/sys-clk/common/include/sysclk/client/ipc.h
@@ -48,7 +48,6 @@ Result sysclkIpcSetProfiles(u64 tid, SysClkTitleProfileList* profiles);
 Result sysclkIpcGetConfigValues(SysClkConfigValueList* out_configValues);
 Result sysclkIpcSetConfigValues(SysClkConfigValueList* configValues);
 Result sysclkIpcGetFreqList(SysClkModule module, u32* list, u32 maxCount, u32* outCount);
-Result sysclkIpcSetReverseNXRTMode(ReverseNXMode mode);
 Result hocClkIpcSetKipData();
 Result hocClkIpcGetKipData();
 Result hocClkIpcUpdateEmcRegs();
diff --git a/Source/sys-clk/common/include/sysclk/config.h b/Source/sys-clk/common/include/sysclk/config.h
index 342e048a..d5f14773 100644
--- a/Source/sys-clk/common/include/sysclk/config.h
+++ b/Source/sys-clk/common/include/sysclk/config.h
@@ -59,6 +59,8 @@ typedef enum {
     HorizonOCConfigValue_DVFSMode,
     HorizonOCConfigValue_DVFSOffset,
 
+    HorizonOCConfigValue_EnableExperimentalSettings,
+
     HorizonOCConfigValue_GPUScheduling,
 
     KipConfigValue_custRev,
@@ -230,6 +232,10 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr
 
         case HorizonOCConfigValue_GPUScheduling:
             return pretty ? "GPU Scheduling" : "gpu_scheduling";
+
+        case HorizonOCConfigValue_EnableExperimentalSettings:
+            return pretty ? "Enable Experimental Settings" : "enable_experimental_settings";
+
         // KIP config values
         case KipConfigValue_custRev:
             return pretty ? "Custom Revision" : "kip_cust_rev";
@@ -450,6 +456,7 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in
         case HorizonOCConfigValue_OverwriteRefreshRate:
         case HorizonOCConfigValue_EnableUnsafeDisplayFreqs:
         case HocClkConfigValue_IsFirstLoad:
+        case HorizonOCConfigValue_EnableExperimentalSettings:
             return (input & 0x1) == input;
 
         case KipConfigValue_custRev:
diff --git a/Source/sys-clk/common/include/sysclk/ipc.h b/Source/sys-clk/common/include/sysclk/ipc.h
index f5f0016b..6f0f6146 100644
--- a/Source/sys-clk/common/include/sysclk/ipc.h
+++ b/Source/sys-clk/common/include/sysclk/ipc.h
@@ -48,9 +48,8 @@ enum SysClkIpcCmd
     SysClkIpcCmd_GetConfigValues = 9,
     SysClkIpcCmd_SetConfigValues = 10,
     SysClkIpcCmd_GetFreqList = 11,
-    SysClkIpcCmd_SetReverseNXRTMode = 12,
-    HocClkIpcCmd_SetKipData = 13,
-    HocClkIpcCmd_GetKipData = 14,
+    HocClkIpcCmd_SetKipData = 12,
+    HocClkIpcCmd_GetKipData = 13,
 };
 
 
diff --git a/Source/sys-clk/common/src/client/ipc.c b/Source/sys-clk/common/src/client/ipc.c
index ed3fa55f..30508523 100644
--- a/Source/sys-clk/common/src/client/ipc.c
+++ b/Source/sys-clk/common/src/client/ipc.c
@@ -153,12 +153,6 @@ Result sysclkIpcGetFreqList(SysClkModule module, u32* list, u32 maxCount, u32* o
     );
 }
 
-Result sysclkIpcSetReverseNXRTMode(ReverseNXMode mode)
-{
-    return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetReverseNXRTMode, mode);
-}
-
-
 Result hocClkIpcSetKipData()
 {
     u32 temp = 0;
diff --git a/Source/sys-clk/common/src/display_refresh_rate.cpp b/Source/sys-clk/common/src/display_refresh_rate.cpp
index 1dc8ca21..d51a1779 100644
--- a/Source/sys-clk/common/src/display_refresh_rate.cpp
+++ b/Source/sys-clk/common/src/display_refresh_rate.cpp
@@ -42,10 +42,25 @@ static bool g_canChangeRefreshRateDocked = false;
 static uint8_t g_lastVActiveSet = 0;
 
 // Refresh rate tables
-static const uint8_t g_dockedRefreshRates[] = {40, 45, 50, 55, 60, 70, 72, 75, 80, 90, 95, 100, 110, 120, 130, 144, 150, 160, 165, 170, 180, 190, 200, 210, 220, 230, 240};
+static const uint8_t g_dockedRefreshRates[] = {40, 45, 50, 55, 60, 70, 72, 75, 80, 90, 95, 100, 110, 120, 130, 140, 144, 150, 160, 165, 170, 180, 190, 200, 210, 220, 230, 240};
 static bool g_dockedAllowed[sizeof(g_dockedRefreshRates) / sizeof(g_dockedRefreshRates[0])] = {0};
 static bool g_dockedAllowed720p[sizeof(g_dockedRefreshRates) / sizeof(g_dockedRefreshRates[0])] = {0};
+// Calculate with this tool:
 
+// https://tomverbeure.github.io/video_timings_calculator?horiz_pixels=1920&vert_pixels=1080&refresh_rate=240&margins=false&interlaced=false&bpc=8&color_fmt=rgb444&video_opt=false&custom_hblank=80&custom_vblank=6
+
+/*
+typedef struct {
+    uint16_t hFrontPorch;
+    uint8_t hSyncWidth;
+    uint8_t hBackPorch;
+    uint8_t vFrontPorch;
+    uint8_t vSyncWidth;
+    uint8_t vBackPorch;
+    uint8_t VIC;
+    uint32_t pixelClock_kHz;
+} DockedTimings;
+*/
 static const DockedTimings g_dockedTimings1080p[] = {
     {8, 32, 40, 7, 8, 6, 0, 88080},        // 40Hz
     {8, 32, 40, 9, 8, 6, 0, 99270},        // 45Hz
@@ -60,7 +75,21 @@ static const DockedTimings g_dockedTimings1080p[] = {
     {8, 32, 40, 36, 8, 6, 0, 214700},      // 95Hz
     {528, 44, 148, 4, 5, 36, 64, 297000},  // 100Hz
     {8, 32, 40, 44, 8, 6, 0, 250360},      // 110Hz
-    {88, 44, 148, 4, 5, 36, 63, 297000}    // 120Hz
+    {88, 44, 148, 4, 5, 36, 63, 297000},   // 120Hz
+    {8, 32, 40, 55, 8, 6, 0, 298750},      //130Hz CVT-RBv2
+    {8, 32, 40, 61, 8, 6, 0, 323400},      //140Hz CVT-RBv2
+    {8, 32, 40, 63, 8, 6, 0, 333216},      //144Hz CVT-RBv2
+    {8, 32, 40, 67, 8, 6, 0, 348300},      //150Hz CVT-RBv2
+    {8, 32, 40, 72, 8, 6, 0, 373120},      //160Hz CVT-RBv2
+    {8, 32, 40, 75, 8, 6, 0, 385770},      //165Hz CVT-RBv2
+    {8, 32, 40, 78, 8, 6, 0, 398480},      //170Hz CVT-RBv2
+    {8, 32, 40, 84, 8, 6, 0, 424080},      //180Hz CVT-RBv2
+    {8, 32, 40, 90, 8, 6, 0, 449920},      //190Hz CVT-RBv2
+    {8, 32, 40, 96, 8, 6, 0, 476000},      //200Hz CVT-RBv2
+    {8, 32, 40, 102, 8, 6, 0, 502320},     //210Hz CVT-RBv2
+    {8, 32, 40, 108, 8, 6, 0, 528880},     //220Hz CVT-RBv2
+    {8, 32, 40, 114, 8, 6, 0, 555680},     //230Hz CVT-RBv2
+    {8, 32, 40, 121, 8, 6, 0, 583200},     //240Hz CVT-RBv2
 };
 
 static const HandheldTimings g_handheldTimingsRETRO[] = {
diff --git a/Source/sys-clk/overlay/Makefile b/Source/sys-clk/overlay/Makefile
index b8756323..406b6617 100644
--- a/Source/sys-clk/overlay/Makefile
+++ b/Source/sys-clk/overlay/Makefile
@@ -39,7 +39,7 @@ include ${TOPDIR}/lib/libultrahand/ultrahand.mk
 # version control constants
 #---------------------------------------------------------------------------------
 #TARGET_VERSION	:= $(shell git describe --dirty --always --tags)
-APP_VERSION		:= 0.39
+APP_VERSION		:= 0.40
 TARGET_VERSION := $(APP_VERSION)
 
 #---------------------------------------------------------------------------------
diff --git a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp
index 9594a060..92945126 100644
--- a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp
+++ b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp
@@ -95,7 +95,8 @@ void AppProfileGui::openValueChoiceGui(
         enableThresholds,
         labels,
         namedValues,
-        showDefaultValue
+        showDefaultValue,
+        true
     );
 }
 
@@ -158,12 +159,12 @@ void AppProfileGui::addModuleListItemValue(
     const std::string& suffix,
     std::uint32_t divisor,
     int decimalPlaces,
-    ValueThresholds thresholds
+    ValueThresholds thresholds,
+    std::vector<NamedValue> namedValues
 )
 {
     tsl::elm::ListItem* listItem =
         new tsl::elm::ListItem(sysclkFormatModule(module, true));
-
     std::uint32_t storedValue = this->profileList->mhzMap[profile][module];
     if (storedValue == 0) {
         listItem->setValue(FREQ_DEFAULT_TEXT);
@@ -177,7 +178,6 @@ void AppProfileGui::addModuleListItemValue(
         }
         listItem->setValue(buf);
     }
-
     listItem->setClickListener(
         [this,
          listItem,
@@ -190,13 +190,13 @@ void AppProfileGui::addModuleListItemValue(
          suffix,
          divisor,
          decimalPlaces,
-         thresholds](u64 keys)
+         thresholds,
+         namedValues](u64 keys)
         {
             if ((keys & HidNpadButton_A) == HidNpadButton_A)
             {
                 std::uint32_t currentValue =
                     this->profileList->mhzMap[profile][module] * divisor;
-
                 ValueRange range(
                     min,
                     max,
@@ -205,17 +205,14 @@ void AppProfileGui::addModuleListItemValue(
                     divisor,
                     decimalPlaces
                 );
-
                 this->openValueChoiceGui(
                     listItem,
                     currentValue,
                     range,
                     categoryName,
-
                     [this, listItem, profile, module, divisor, suffix, decimalPlaces, thresholds](std::uint32_t value) -> bool
                     {
                         this->profileList->mhzMap[profile][module] = value / divisor;
-
                         if (value == 0) {
                             listItem->setValue(FREQ_DEFAULT_TEXT);
                         } else {
@@ -230,11 +227,9 @@ void AppProfileGui::addModuleListItemValue(
                             }
                             listItem->setValue(buf);
                         }
-
                         Result rc =
                             sysclkIpcSetProfiles(this->applicationId,
                                                  this->profileList);
-
                         if (R_FAILED(rc))
                         {
                             FatalGui::openWithResultCode(
@@ -243,34 +238,30 @@ void AppProfileGui::addModuleListItemValue(
                         }
                         return true;
                     },
-
                     thresholds,
-                    false
+                    false,
+                    {},
+                    namedValues,
+                    true
                 );
-
                 return true;
             }
             else if ((keys & HidNpadButton_Y) == HidNpadButton_Y)
             {
                 this->profileList->mhzMap[profile][module] = 0;
                 listItem->setValue(FREQ_DEFAULT_TEXT);
-
                 Result rc =
                     sysclkIpcSetProfiles(this->applicationId,
                                          this->profileList);
-
                 if (R_FAILED(rc))
                 {
                     FatalGui::openWithResultCode("sysclkIpcSetProfiles", rc);
                     return false;
                 }
-
                 return true;
             }
-
             return false;
         });
-
     this->listElement->addItem(listItem);
 }
 
@@ -279,7 +270,7 @@ void AppProfileGui::addProfileUI(SysClkProfile profile)
     BaseMenuGui::refresh();
     if(!this->context)
         return;
-    Result rc = sysclkIpcGetConfigValues(&configList); // idk why this is needed, probably some refreshing issue
+    Result rc = sysclkIpcGetConfigValues(&configList);
     if (R_FAILED(rc)) [[unlikely]] {
         FatalGui::openWithResultCode("sysclkIpcGetConfigValues", rc);
         return;
@@ -291,10 +282,77 @@ void AppProfileGui::addProfileUI(SysClkProfile profile)
     #if IS_MINIMAL == 0
         ValueThresholds lcdThresholds(60, 65);
         if(!IsHoag() && configList.values[HorizonOCConfigValue_OverwriteRefreshRate]) {
-            if(profile != SysClkProfile_Docked)
+            if(profile != SysClkProfile_Docked) {
                 this->addModuleListItemValue(profile, HorizonOCModule_Display, "Display", IsAula() ? 45 : 40, configList.values[HorizonOCConfigValue_EnableUnsafeDisplayFreqs] ? IsAula() ? 65 : 72 : 60, 1, " Hz", 1, 0, lcdThresholds);
-            else
-                this->addModuleListItemValue(profile, HorizonOCModule_Display, "Display", 50, IsAula() ? this->context->isSysDockInstalled ? 120 : 75 : 120, 5, " Hz", 1, 0);
+            } else {
+                if(IsAula() && this->context->isSysDockInstalled) {
+                    std::vector<NamedValue> dockedFreqs = {
+                        NamedValue("40 Hz", 40),
+                        NamedValue("45 Hz", 45),
+                        NamedValue("50 Hz", 50),
+                        NamedValue("55 Hz", 55),
+                        NamedValue("60 Hz", 60),
+                        NamedValue("70 Hz", 70),
+                        NamedValue("72 Hz", 72),
+                        NamedValue("75 Hz", 75),
+                        NamedValue("80 Hz", 80),
+                        NamedValue("90 Hz", 90),
+                        NamedValue("95 Hz", 95),
+                        NamedValue("100 Hz", 100),
+                        NamedValue("110 Hz", 110),
+                        NamedValue("120 Hz", 120),
+                        NamedValue("130 Hz", 130),
+                        NamedValue("140 Hz", 140),
+                        NamedValue("144 Hz", 144),
+                        NamedValue("150 Hz", 150),
+                        NamedValue("160 Hz", 160),
+                        NamedValue("165 Hz", 165),
+                        NamedValue("170 Hz", 170),
+                        NamedValue("180 Hz", 180),
+                        NamedValue("190 Hz", 190),
+                        NamedValue("200 Hz", 200),
+                        NamedValue("210 Hz", 210),
+                        NamedValue("220 Hz", 220),
+                        NamedValue("230 Hz", 230),
+                        NamedValue("240 Hz", 240)
+                    };
+                    
+                    this->addModuleListItemValue(profile, HorizonOCModule_Display, "Display", 40, 240, 1, " Hz", 1, 0, ValueThresholds(), dockedFreqs);
+                } else if (IsAula() && !this->context->isSysDockInstalled) {
+                    std::vector<NamedValue> dockedFreqsLimited = {
+                        NamedValue("50 Hz", 50),
+                        NamedValue("55 Hz", 55),
+                        NamedValue("60 Hz", 60),
+                        NamedValue("65 Hz", 65),
+                        NamedValue("70 Hz", 70),
+                        NamedValue("72 Hz", 72),
+                        NamedValue("75 Hz", 75)
+                    };
+                    
+                    this->addModuleListItemValue(profile, HorizonOCModule_Display, "Display", 50, 75, 1, " Hz", 1, 0, ValueThresholds(), dockedFreqsLimited);
+                } else {
+                    std::vector<NamedValue> dockedFreqsStandard = {
+                        NamedValue("50 Hz", 50),
+                        NamedValue("55 Hz", 55),
+                        NamedValue("60 Hz", 60),
+                        NamedValue("65 Hz", 65),
+                        NamedValue("70 Hz", 70),
+                        NamedValue("72 Hz", 72),
+                        NamedValue("75 Hz", 75),
+                        NamedValue("80 Hz", 80),
+                        NamedValue("85 Hz", 85),
+                        NamedValue("90 Hz", 90),
+                        NamedValue("95 Hz", 95),
+                        NamedValue("100 Hz", 100),
+                        NamedValue("105 Hz", 105),
+                        NamedValue("110 Hz", 110),
+                        NamedValue("115 Hz", 115),
+                        NamedValue("120 Hz", 120)
+                    };
+                    
+                    this->addModuleListItemValue(profile, HorizonOCModule_Display, "Display", 50, 120, 1, " Hz", 1, 0, ValueThresholds(), dockedFreqsStandard);
+                }
+            }
         }
     #endif
     this->addModuleListItemToggle(profile, HorizonOCModule_Governor);
diff --git a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h
index 76ec4b9d..f6697b1a 100644
--- a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h
+++ b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h
@@ -64,7 +64,8 @@ class AppProfileGui : public BaseMenuGui
             const std::string& suffix,
             std::uint32_t divisor,
             int decimalPlaces,
-            ValueThresholds thresholds = {}
+            ValueThresholds thresholds,
+            std::vector<NamedValue> namedValues = {}
         );
         void addProfileUI(SysClkProfile profile);
 
diff --git a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp
index 67a57ad0..efdc0ca6 100644
--- a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp
+++ b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp
@@ -118,32 +118,32 @@ void FreqChoiceGui::listUI()
         std::uint32_t hz = this->hzList[i];
         uint32_t mhz = hz / 1000000;
 
-        if (checkMax && IsMariko()) {
-            if (moduleName == "cpu" &&
-                this->configList->values[HocClkConfigValue_MarikoMaxCpuClock] < mhz)
-                continue;
+        // if (checkMax && IsMariko()) {
+        //     if (moduleName == "cpu" &&
+        //         this->configList->values[HocClkConfigValue_MarikoMaxCpuClock] < mhz)
+        //         continue;
 
-            // if (moduleName == "gpu" &&
-            //     this->configList->values[HocClkConfigValue_MarikoMaxGpuClock] < mhz)
-            //     continue;
+        //     // if (moduleName == "gpu" &&
+        //     //     this->configList->values[HocClkConfigValue_MarikoMaxGpuClock] < mhz)
+        //     //     continue;
 
-            // if (moduleName == "mem" &&
-            //     this->configList->values[HocClkConfigValue_MarikoMaxMemClock] < mhz)
-            //     continue;
+        //     // if (moduleName == "mem" &&
+        //     //     this->configList->values[HocClkConfigValue_MarikoMaxMemClock] < mhz)
+        //     //     continue;
 
-        } else if (checkMax && IsErista()) {
-            if (moduleName == "cpu" &&
-                this->configList->values[HocClkConfigValue_EristaMaxCpuClock] < mhz)
-                continue;
+        // } else if (checkMax && IsErista()) {
+        //     if (moduleName == "cpu" &&
+        //         this->configList->values[HocClkConfigValue_EristaMaxCpuClock] < mhz)
+        //         continue;
 
-            // if (moduleName == "gpu" &&
-            //     this->configList->values[HocClkConfigValue_EristaMaxGpuClock] < mhz)
-            //     continue;
+        //     // if (moduleName == "gpu" &&
+        //     //     this->configList->values[HocClkConfigValue_EristaMaxGpuClock] < mhz)
+        //     //     continue;
 
-            // if (moduleName == "mem" &&
-            //     this->configList->values[HocClkConfigValue_EristaMaxMemClock] < mhz)
-            //     continue;
-        }
+        //     // if (moduleName == "mem" &&
+        //     //     this->configList->values[HocClkConfigValue_EristaMaxMemClock] < mhz)
+        //     //     continue;
+        // }
 
         if (moduleName == "mem" && mhz <= 600)
             continue;
diff --git a/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp
index a0e1c6e8..33a70377 100644
--- a/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp
+++ b/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp
@@ -239,15 +239,22 @@ void MiscGui::addFreqButton(SysClkConfigValue configVal,
 
 void MiscGui::listUI()
 {
+    Result rc = sysclkIpcGetConfigValues(configList);
+    if (R_FAILED(rc)) [[unlikely]] {
+        FatalGui::openWithResultCode("sysclkIpcGetConfigValues", rc);
+        return;
+    }    
+
     ValueThresholds thresholdsDisabled(0, 0);
     std::vector<NamedValue> noNamedValues = {};
 
-
-
     this->listElement->addItem(new tsl::elm::CategoryHeader("Settings"));
 
-    addConfigToggle(HocClkConfigValue_UncappedClocks, nullptr);
     addConfigToggle(HocClkConfigValue_OverwriteBoostMode, nullptr);
+
+
+    this->listElement->addItem(new tsl::elm::CategoryHeader("Safety Settings"));
+    addConfigToggle(HocClkConfigValue_UncappedClocks, nullptr);
     addConfigToggle(HocClkConfigValue_ThermalThrottle, nullptr);
     addConfigToggle(HocClkConfigValue_HandheldTDP, nullptr);
 //  addConfigToggle(HocClkConfigValue_EnforceBoardLimit, nullptr);
@@ -289,13 +296,8 @@ void MiscGui::listUI()
         );
     #endif
 
-    if(IsMariko()) {
-        addFreqButton(HocClkConfigValue_MarikoMaxCpuClock, nullptr, SysClkModule_CPU, cpu_freq_label_m);
-    } else {
-        addFreqButton(HocClkConfigValue_EristaMaxCpuClock, nullptr, SysClkModule_CPU, cpu_freq_label_e);
-    }
-
     if (IsMariko()) {
+        this->listElement->addItem(new tsl::elm::CategoryHeader("DVFS"));
         std::vector<NamedValue> dvfsValues = {
             NamedValue("Disabled", DVFSMode_Disabled),
             NamedValue("PCV Hijack", DVFSMode_Hijack),
@@ -331,8 +333,20 @@ void MiscGui::listUI()
         };
 
         addConfigButton(HorizonOCConfigValue_DVFSOffset, "GPU DVFS Offset", ValueRange(0, 12, 1, "", 0), "GPU DVFS Offset", &thresholdsDisabled, {}, dvfsOffset, false);
-
     }
+        
+    this->listElement->addItem(new tsl::elm::CategoryHeader("Display"));
+
+    addConfigToggle(HorizonOCConfigValue_OverwriteRefreshRate, nullptr);
+    tsl::elm::CustomDrawer* warningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) {
+        renderer->drawString("\uE150 Enabling unsafe display", false, x + 20, y + 30, 18, tsl::style::color::ColorText);
+        renderer->drawString("refresh rates may cause stress", false, x + 20, y + 50, 18, tsl::style::color::ColorText);
+        renderer->drawString("or damage to your display! ", false, x + 20, y + 70, 18, tsl::style::color::ColorText);
+        renderer->drawString("Proceed at your own risk!", false, x + 20, y + 90, 18, tsl::style::color::ColorText);
+    });
+    warningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 110);
+    this->listElement->addItem(warningText);
+    addConfigToggle(HorizonOCConfigValue_EnableUnsafeDisplayFreqs, nullptr);
 
     this->listElement->addItem(new tsl::elm::CategoryHeader("KIP"));
 
@@ -394,92 +408,92 @@ void MiscGui::listUI()
         //     NamedValue("2816mA", 2816),
         //     NamedValue("3072mA", 3072),
         // };
-        this->listElement->addItem(new tsl::elm::CategoryHeader("Experimental"));
-        
-        std::vector<NamedValue> gpuSchedValues = {
-            NamedValue("Do not override", GpuSchedulingMode_DoNotOverride),
-            NamedValue("Enabled", GpuSchedulingMode_Enabled, "96.5% limit"),
-            NamedValue("Disabled", GpuSchedulingMode_Disabled, "99.7% limit"),
-        };
-        tsl::elm::CustomDrawer* gpuSchedInfoText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) {
-            renderer->drawString("\uE150 This option requires a reboot", false, x + 20, y + 30, 18, tsl::style::color::ColorText);
-            renderer->drawString("to take effect", false, x + 20, y + 50, 18, tsl::style::color::ColorText);
-        });
-        gpuSchedInfoText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 70);
-        this->listElement->addItem(gpuSchedInfoText);
-        addConfigButton(
-            HorizonOCConfigValue_GPUScheduling,
-            "GPU Scheduling Override",
-            ValueRange(0, 0, 1, "", 0),
-            "GPU Scheduling Override",
-            &thresholdsDisabled,
-            {},
-            gpuSchedValues,
-            false
-        );
-        if(!IsHoag()) {
-            //     std::vector<NamedValue> chargerCurrents = {
-            //         NamedValue("Disabled", 0),
-            //         NamedValue("1024mA", 1024),
-            //         NamedValue("1280mA", 1280),
-            //         NamedValue("1536mA", 1536),
-            //         NamedValue("1792mA", 1792),
-            //         NamedValue("2048mA", 2048),
-            //         NamedValue("2304mA", 2304),
-            //         NamedValue("2560mA", 2560),
-            //         NamedValue("2816mA", 2816),
-            //         NamedValue("3072mA", 3072),
-            //     };
-
-            //     ValueThresholds chargerThresholds(2048, 2560);
-
-            //     addConfigButton(
-            //         HorizonOCConfigValue_BatteryChargeCurrent,
-            //         "Charge Current Override",
-            //         ValueRange(0, 0, 1, "", 0),
-            //         "Charge Current Override",
-            //         &chargerThresholds,
-            //         {},
-            //         chargerCurrents,
-            //         false
-            //     );
-            addConfigToggle(HorizonOCConfigValue_OverwriteRefreshRate, nullptr);
-            tsl::elm::CustomDrawer* warningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) {
-                renderer->drawString("\uE150 Enabling unsafe display", false, x + 20, y + 30, 18, tsl::style::color::ColorText);
-                renderer->drawString("refresh rates may cause stress", false, x + 20, y + 50, 18, tsl::style::color::ColorText);
-                renderer->drawString("or damage to your display! ", false, x + 20, y + 70, 18, tsl::style::color::ColorText);
-                renderer->drawString("Proceed at your own risk!", false, x + 20, y + 90, 18, tsl::style::color::ColorText);
+        if(this->configList->values[HorizonOCConfigValue_EnableExperimentalSettings]) {
+            this->listElement->addItem(new tsl::elm::CategoryHeader("Experimental"));
+            
+            std::vector<NamedValue> gpuSchedValues = {
+                NamedValue("Do not override", GpuSchedulingMode_DoNotOverride),
+                NamedValue("Enabled", GpuSchedulingMode_Enabled, "96.5% limit"),
+                NamedValue("Disabled", GpuSchedulingMode_Disabled, "99.7% limit"),
+            };
+            tsl::elm::CustomDrawer* gpuSchedInfoText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) {
+                renderer->drawString("\uE150 This option requires a reboot", false, x + 20, y + 30, 18, tsl::style::color::ColorText);
+                renderer->drawString("to take effect", false, x + 20, y + 50, 18, tsl::style::color::ColorText);
             });
-            warningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 110);
-            this->listElement->addItem(warningText);
-            addConfigToggle(HorizonOCConfigValue_EnableUnsafeDisplayFreqs, nullptr);
+            gpuSchedInfoText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 70);
+            this->listElement->addItem(gpuSchedInfoText);
+            addConfigButton(
+                HorizonOCConfigValue_GPUScheduling,
+                "GPU Scheduling Override",
+                ValueRange(0, 0, 1, "", 0),
+                "GPU Scheduling Override",
+                &thresholdsDisabled,
+                {},
+                gpuSchedValues,
+                false
+            );
+            tsl::elm::CustomDrawer* chargeWarningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) {
+                renderer->drawString("\uE150 Overriding the charge current", false, x + 20, y + 30, 18, tsl::style::color::ColorText);
+                renderer->drawString("can be dangerous and may cause", false, x + 20, y + 50, 18, tsl::style::color::ColorText);
+                renderer->drawString("damage to your battery or charger!", false, x + 20, y + 70, 18, tsl::style::color::ColorText);
+            });
+            chargeWarningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 90);
+            this->listElement->addItem(chargeWarningText);
+
+            if(!IsHoag()) {
+                    std::vector<NamedValue> chargerCurrents = {
+                        NamedValue("Disabled", 0),
+                        NamedValue("1024mA", 1024),
+                        NamedValue("1280mA", 1280),
+                        NamedValue("1536mA", 1536),
+                        NamedValue("1792mA", 1792),
+                        NamedValue("2048mA", 2048),
+                        NamedValue("2304mA", 2304),
+                        NamedValue("2560mA", 2560),
+                        NamedValue("2816mA", 2816),
+                        NamedValue("3072mA", 3072),
+                    };
+
+                    ValueThresholds chargerThresholds(2048, 2049);
+
+                    addConfigButton(
+                        HorizonOCConfigValue_BatteryChargeCurrent,
+                        "Charge Current Override",
+                        ValueRange(0, 0, 1, "", 0),
+                        "Charge Current Override",
+                        &chargerThresholds,
+                        {},
+                        chargerCurrents,
+                        false
+                    );
+            }
+            else {
+                std::vector<NamedValue> chargerCurrents = {
+                    NamedValue("Disabled", 0),
+                    NamedValue("1024mA", 1024),
+                    NamedValue("1280mA", 1280),
+                    NamedValue("1536mA", 1536),
+                    NamedValue("1792mA", 1792),
+                    NamedValue("2048mA", 2048),
+                    NamedValue("2304mA", 2304),
+                    NamedValue("2560mA", 2560),
+                };
+
+                ValueThresholds chargerThresholds(1792, 1793);
+
+                addConfigButton(
+                    HorizonOCConfigValue_BatteryChargeCurrent,
+                    "Charge Current Override",
+                    ValueRange(0, 0, 1, "", 0),
+                    "Charge Current Override",
+                    &chargerThresholds,
+                    {},
+                    chargerCurrents,
+                    false
+                );
+
+            }
         }
-        //  else {
-        //     std::vector<NamedValue> chargerCurrents = {
-        //         NamedValue("Disabled", 0),
-        //         NamedValue("1024mA", 1024),
-        //         NamedValue("1280mA", 1280),
-        //         NamedValue("1536mA", 1536),
-        //         NamedValue("1792mA", 1792),
-        //         NamedValue("2048mA", 2048),
-        //         NamedValue("2304mA", 2304),
-        //         NamedValue("2560mA", 2560),
-        //     };
-
-        //     ValueThresholds chargerThresholds(1792, 2048);
-
-        //     addConfigButton(
-        //         HorizonOCConfigValue_BatteryChargeCurrent,
-        //         "Charge Current Override",
-        //         ValueRange(0, 0, 1, "", 0),
-        //         "Charge Current Override",
-        //         &chargerThresholds,
-        //         {},
-        //         chargerCurrents,
-        //         false
-        //     );
-
-        // }
     #endif
 
 }
diff --git a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp
index fc304188..eb15316e 100644
--- a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp
+++ b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp
@@ -30,7 +30,8 @@ ValueChoiceGui::ValueChoiceGui(std::uint32_t selectedValue,
                                bool enableThresholds,
                                std::map<std::uint32_t, std::string> labels,
                                std::vector<NamedValue> namedValues,
-                               bool showDefaultValue)
+                               bool showDefaultValue,
+                               bool showDNO)
     : selectedValue(selectedValue),
       range(range),
       categoryName(categoryName),
@@ -39,7 +40,8 @@ ValueChoiceGui::ValueChoiceGui(std::uint32_t selectedValue,
       enableThresholds(enableThresholds),
       labels(labels),
       namedValues(namedValues),
-      showDefaultValue(showDefaultValue)
+      showDefaultValue(showDefaultValue),
+      showDNO(showDNO)
 {
 }
 
@@ -52,7 +54,7 @@ std::string ValueChoiceGui::formatValue(std::uint32_t value)
     std::ostringstream oss;
     if(showDefaultValue) {
         if (value == 0) {
-            return VALUE_DEFAULT_TEXT;
+            return this->showDNO ? FREQ_DEFAULT_TEXT : VALUE_DEFAULT_TEXT;
         }
     }
     double displayValue = static_cast<double>(value) / static_cast<double>(range.divisor);
@@ -164,17 +166,16 @@ void ValueChoiceGui::listUI()
     if (!categoryName.empty()) {
         this->listElement->addItem(new tsl::elm::CategoryHeader(categoryName));
     }
-    
+
+    if (showDefaultValue) {
+        this->listElement->addItem(this->createValueListItem(0, this->selectedValue == 0, 0));
+    }
     for (const auto& namedValue : namedValues) {
         int safety = enableThresholds ? getSafetyLevel(namedValue.value) : 0;
         bool selected = (namedValue.value == this->selectedValue);
         this->listElement->addItem(this->createNamedValueListItem(namedValue, selected, safety));
     }
     
-    if (showDefaultValue) {
-        this->listElement->addItem(this->createValueListItem(0, this->selectedValue == 0, 0));
-    }
-    
     if (namedValues.empty()) {
         for (std::uint32_t value = range.min; value <= range.max; value += range.step)
         {
diff --git a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h
index e6324fc3..49c7883d 100644
--- a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h
+++ b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h
@@ -71,7 +71,7 @@ protected:
     
     std::vector<NamedValue> namedValues;
     bool showDefaultValue = true;
-    
+    bool showDNO = false;
     tsl::elm::ListItem* createValueListItem(std::uint32_t value, bool selected, int safety);
     tsl::elm::ListItem* createNamedValueListItem(const NamedValue& namedValue, bool selected, int safety);
     std::string formatValue(std::uint32_t value);
@@ -86,7 +86,8 @@ public:
                    bool enableThresholds = false,
                    std::map<std::uint32_t, std::string> labels = {},
                    std::vector<NamedValue> namedValues = {},
-                   bool showDefaultValue = true);
+                   bool showDefaultValue = true,
+                   bool showDNO = false);
     ~ValueChoiceGui();
     
     void addNamedValue(const std::string& name, std::uint32_t value, const std::string& rightText = "")
diff --git a/Source/sys-clk/sysmodule/src/clock_manager.cpp b/Source/sys-clk/sysmodule/src/clock_manager.cpp
index 7d387428..d11d348f 100644
--- a/Source/sys-clk/sysmodule/src/clock_manager.cpp
+++ b/Source/sys-clk/sysmodule/src/clock_manager.cpp
@@ -39,7 +39,6 @@
 #include <cstring>
 #include <cstdio>
 #include <crc32.h>
-#include <sys/stat.h>
 
 #define HOSPPC_HAS_BOOST (hosversionAtLeast(7,0,0))
 bool isGovernorEnabled = false; // to avoid thread messes
@@ -90,7 +89,7 @@ ClockManager::ClockManager()
     this->lastTempLogNs = 0;
     this->lastCsvWriteNs = 0;
 
-    this->rnxSync = new ReverseNXSync;
+    this->sysDockIntegration = new SysDockIntegration;
     memset(&initialConfigValues, 0, sizeof(initialConfigValues));
     this->GetKipData();
     threadCreate(
@@ -115,13 +114,7 @@ ClockManager::ClockManager()
     previousRamHz = Board::GetHz(SysClkModule_MEM);
     Board::SetGpuSchedulingMode((GpuSchedulingMode)this->config->GetConfigValue(HorizonOCConfigValue_GPUScheduling));
     this->context->gpuSchedulingMode = (GpuSchedulingMode)this->config->GetConfigValue(HorizonOCConfigValue_GPUScheduling);
-    
-    struct stat st = {0};
-    if (stat("sdmc:/atmosphere/contents/42000000000000A0", &st) == 0 && S_ISDIR(st.st_mode)) {
-        this->context->isSysDockInstalled = true;
-    } else {
-        this->context->isSysDockInstalled = false;
-    }
+    this->context->isSysDockInstalled = this->sysDockIntegration->getCurrentSysDockState();
 }
 
 ClockManager::~ClockManager()
@@ -615,7 +608,6 @@ bool ClockManager::RefreshContext()
         FileUtils::LogLine("[mgr] TitleID change: %016lX", applicationId);
         this->context->applicationId = applicationId;
         hasChanged = true;
-        this->rnxSync->Reset(applicationId);
     }
 
     SysClkProfile profile = Board::GetProfile();
@@ -629,7 +621,6 @@ bool ClockManager::RefreshContext()
     // restore clocks to stock values on app or profile change
     if (hasChanged)
     {
-        // this->rnxSync->ToggleSync(this->GetConfig()->GetConfigValue(HocClkConfigValue_SyncReverseNXMode));
         Board::ResetToStock();
         if (Board::GetSocType() == SysClkSocType_Mariko && this->config->GetConfigValue(HorizonOCConfigValue_DVFSMode) == DVFSMode_Hijack) {
             Board::PcvHijackDvfs(0);
@@ -773,11 +764,6 @@ bool ClockManager::RefreshContext()
     return hasChanged;
 }
 
-void ClockManager::SetRNXRTMode(ReverseNXMode mode)
-{
-    this->rnxSync->SetRTMode(mode);
-}
-
 void ClockManager::SetKipData() {
     // TODO: figure out if this REALLY causes issues (i doubt it)
     // if(Board::GetSocType() == SysClkSocType_Mariko) {
diff --git a/Source/sys-clk/sysmodule/src/clock_manager.h b/Source/sys-clk/sysmodule/src/clock_manager.h
index 9cbe5554..4c27ecad 100644
--- a/Source/sys-clk/sysmodule/src/clock_manager.h
+++ b/Source/sys-clk/sysmodule/src/clock_manager.h
@@ -37,7 +37,7 @@
 #include "integrations.h"
 void governorThread(void*);
 
-class ReverseNXSync;
+class SysDockIntegration;
 
 class ClockManager
 {
@@ -58,7 +58,6 @@ class ClockManager
     void Tick();
     void ResetToStockClocks();
     void WaitForNextTick();
-    void SetRNXRTMode(ReverseNXMode mode);
     void SetKipData();
     void GetKipData();
     static void GovernorThread(void* arg);
@@ -87,5 +86,5 @@ class ClockManager
     std::uint64_t lastFreqLogNs;
     std::uint64_t lastPowerLogNs;
     std::uint64_t lastCsvWriteNs;
-    ReverseNXSync *rnxSync;
+    SysDockIntegration *sysDockIntegration;
 };
diff --git a/Source/sys-clk/sysmodule/src/integrations.cpp b/Source/sys-clk/sysmodule/src/integrations.cpp
index 6b69890a..cd55661d 100644
--- a/Source/sys-clk/sysmodule/src/integrations.cpp
+++ b/Source/sys-clk/sysmodule/src/integrations.cpp
@@ -17,68 +17,16 @@
  
 
 #include "integrations.h"
+#include <sys/stat.h>
 
-ReverseNXSync::ReverseNXSync()
-    : m_rt_mode(ReverseNX_NotFound), m_tool_mode(ReverseNX_NotFound) {
-    FILE *fp = fopen("/atmosphere/contents/0000000000534C56/flags/boot2.flag", "r");
-    m_tool_enabled = fp ? true : false;
-    if (fp)
-        fclose(fp);
+SysDockIntegration::SysDockIntegration() {
 }
 
-SysClkProfile ReverseNXSync::GetProfile(SysClkProfile real) {
-    switch (this->GetMode()) {
-        case ReverseNX_Docked:
-            return SysClkProfile_Docked;
-        case ReverseNX_Handheld:
-            if (real == SysClkProfile_Docked)
-                return SysClkProfile_HandheldChargingOfficial;
-        default:
-            return real;
+bool SysDockIntegration::getCurrentSysDockState() {
+    struct stat st = {0};
+    if (stat("sdmc:/atmosphere/contents/42000000000000A0", &st) == 0 && S_ISDIR(st.st_mode)) {
+        return true;
+    } else {
+        return false;
     }
-}
-
-ReverseNXMode ReverseNXSync::GetMode() {
-    if (!this->m_sync_enabled)
-        return ReverseNX_NotFound;
-    if (this->m_rt_mode)
-        return this->m_rt_mode;
-    return this->m_tool_mode;
-}
-
-ReverseNXMode ReverseNXSync::GetToolModeFromPatch(const char* patch_path) {
-    constexpr uint32_t DOCKED_MAGIC = 0x320003E0;
-    constexpr uint32_t HANDHELD_MAGIC = 0x52A00000;
-    FILE *fp = fopen(patch_path, "rb");
-    if (fp) {
-        uint32_t buf = 0;
-        fread(&buf, sizeof(buf), 1, fp);
-        fclose(fp);
-
-        if (buf == DOCKED_MAGIC)
-            return ReverseNX_Docked;
-        if (buf == HANDHELD_MAGIC)
-            return ReverseNX_Handheld;
-    }
-
-    return ReverseNX_NotFound;
-}
-
-ReverseNXMode ReverseNXSync::RecheckToolMode() {
-    ReverseNXMode mode = ReverseNX_NotFound;
-    if (this->m_tool_enabled) {
-        const char* fileName = "_ZN2nn2oe18GetPerformanceModeEv.asm64"; // or _ZN2nn2oe18GetPerformanceModeEv.asm64
-        const char* filePath = new char[72];
-        SCOPE_EXIT { delete[] filePath; };
-        /* Check per-game patch */
-        snprintf((char*)filePath, 72, "/SaltySD/patches/%016lX/%s", this->m_app_id, fileName);
-        mode = this->GetToolModeFromPatch(filePath);
-        if (!mode) {
-            /* Check global patch */
-            snprintf((char*)filePath, 72, "/SaltySD/patches/%s", fileName);
-            mode = this->GetToolModeFromPatch(filePath);
-        }
-    }
-
-    return mode;
 }
\ No newline at end of file
diff --git a/Source/sys-clk/sysmodule/src/integrations.h b/Source/sys-clk/sysmodule/src/integrations.h
index 357ed0a1..9c2d7ea9 100644
--- a/Source/sys-clk/sysmodule/src/integrations.h
+++ b/Source/sys-clk/sysmodule/src/integrations.h
@@ -29,25 +29,9 @@
 
 #include "clock_manager.h"
 
-class ReverseNXSync {
+class SysDockIntegration {
 public:
-    ReverseNXSync ();
+    SysDockIntegration();
 
-    void ToggleSync(bool enable)    { m_sync_enabled = enable; };
-    void Reset(uint64_t app_id)     { m_app_id = app_id; SetRTMode(ReverseNX_NotFound); GetToolMode(); }
-    ReverseNXMode GetRTMode()           { return m_rt_mode; };
-    void SetRTMode(ReverseNXMode mode)  { m_rt_mode = mode; };
-    ReverseNXMode GetToolMode()         { return m_tool_mode = RecheckToolMode(); };
-    SysClkProfile GetProfile(SysClkProfile real);
-    ReverseNXMode GetMode();
-
-protected:
-    std::atomic<ReverseNXMode> m_rt_mode;
-    ReverseNXMode m_tool_mode;
-    uint64_t m_app_id = 0;
-    bool m_tool_enabled;
-    bool m_sync_enabled;
-
-    ReverseNXMode GetToolModeFromPatch(const char* patch_path);
-    ReverseNXMode RecheckToolMode();
+    bool getCurrentSysDockState();
 };
\ No newline at end of file
diff --git a/Source/sys-clk/sysmodule/src/ipc_service.cpp b/Source/sys-clk/sysmodule/src/ipc_service.cpp
index 0877882c..71ff40a7 100644
--- a/Source/sys-clk/sysmodule/src/ipc_service.cpp
+++ b/Source/sys-clk/sysmodule/src/ipc_service.cpp
@@ -198,12 +198,6 @@ Result IpcService::ServiceHandlerFunc(void* arg, const IpcServerRequest* r, u8*
                 );
             }
             break;
-        case SysClkIpcCmd_SetReverseNXRTMode:
-            if (r->data.size >= sizeof(ReverseNXMode)) {
-                ReverseNXMode mode = *((ReverseNXMode*)r->data.ptr);
-                return ipcSrv->SetReverseNXRTMode(mode);
-            }
-            break;
         case HocClkIpcCmd_SetKipData:
             if (r->data.size >= 0) {
                 return ipcSrv->SetKipData();
@@ -361,10 +355,6 @@ Result IpcService::GetFreqList(SysClkIpc_GetFreqList_Args* args, std::uint32_t*
     return 0;
 }
 
-Result IpcService::SetReverseNXRTMode(ReverseNXMode mode) {
-    return 0;
-}
-
 Result IpcService::SetKipData() {
     this->clockMgr->SetKipData();
 
diff --git a/Source/sys-clk/sysmodule/src/ipc_service.h b/Source/sys-clk/sysmodule/src/ipc_service.h
index 32150912..cded785c 100644
--- a/Source/sys-clk/sysmodule/src/ipc_service.h
+++ b/Source/sys-clk/sysmodule/src/ipc_service.h
@@ -54,7 +54,6 @@ class IpcService
     Result GetConfigValues(SysClkConfigValueList* out_configValues);
     Result SetConfigValues(SysClkConfigValueList* configValues);
     Result GetFreqList(SysClkIpc_GetFreqList_Args* args, std::uint32_t* out_list, std::size_t size, std::uint32_t* out_count);
-    Result SetReverseNXRTMode(ReverseNXMode mode);
     Result SetKipData();
     Result GetKipData();
     bool running;