me when sed goes wrong

[*] nuke unordered-dense, use boost::container::unordered_flat_{map,set}
Signed-off-by: lizzie <lizzie@eden-emu.dev>
2026-08-30 18:30:51 +00:00 · 2026-08-30 08:27:22 +00:00 · 2026-08-30 08:15:47 +00:00 · 2026-08-30 08:24:00 +02:00 · 2026-08-30 08:18:50 +02:00 · 2026-08-30 08:17:54 +02:00
137 changed files with 812 additions and 699 deletions
@@ -1,26 +0,0 @@
-From b3622608433c183ba868a1dc8dd9cf285eb3b916 Mon Sep 17 00:00:00 2001
-From: Dario Petrillo <dario.pk1@gmail.com>
-Date: Thu, 27 Nov 2025 23:12:38 +0100
-Subject: [PATCH] avoid extra memset when clearing an empty table
-
---
- include/ankerl/unordered_dense.h | 6 ++++--
- 1 file changed, 4 insertions(+), 2 deletions(-)
-
-diff --git a/include/ankerl/unordered_dense.h b/include/ankerl/unordered_dense.h
-index 0835342..4938212 100644
--- a/include/ankerl/unordered_dense.h
-+++ b/include/ankerl/unordered_dense.h
-@@ -1490,8 +1490,10 @@ class table : public std::conditional_t<is_map_v<T>, base_table_type_map<T>, bas
-     // modifiers //////////////////////////////////////////////////////////////
- 
-     void clear() {
-        m_values.clear();
-        clear_buckets();
-+        if (!empty()) {
-+            m_values.clear();
-+            clear_buckets();
-+        }
-     }
- 
-     auto insert(value_type const& value) -> std::pair<iterator, bool> {
@@ -540,7 +540,6 @@ add_subdirectory(externals)
 # pass targets from externals
 # TODO(crueter): CPMUtil Propagate func?
 find_package(enet)
-find_package(unordered_dense REQUIRED)

 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
    find_package(xbyak)
@@ -301,17 +301,6 @@
        "repo": "eden-emu/tzdb_to_nx",
        "version": "230326"
    },
-    "unordered-dense": {
-        "bundled": true,
-        "find_args": "CONFIG",
-        "hash": "d2106f6640f6bfb81755e4b8bfb64982e46ec4a507cacdb38f940123212ccf35a20b43c70c6f01d7bfb8c246d1a16f7845d8052971949cea9def1475e3fa02c8",
-        "package": "unordered_dense",
-        "patches": [
-            "0001-avoid-memset-when-clearing-an-empty-table.patch"
-        ],
-        "repo": "martinus/unordered_dense",
-        "version": "7b55cab841"
-    },
    "vulkan-headers": {
        "hash": "d2846ea228415772645eea4b52a9efd33e6a563043dd3de059e798be6391a8f0ca089f455ae420ff22574939ed0f48ed7c6ff3d5a9987d5231dbf3b3f89b484b",
        "min_version": "1.4.317",
@@ -509,6 +509,8 @@ QWidget#contentRichDialog QLabel#label_title_rich {
 }

 QWidget#contentDialog QLabel#label_dialog {
+    background: #2E2E2E;
+
    padding: 20px 65px;
 }

@@ -80,7 +80,6 @@ Certain other dependencies will be fetched by CPM regardless. System packages *c
 * [httplib](https://github.com/yhirose/cpp-httplib) - if `ENABLE_UPDATE_CHECKER` or `ENABLE_WEB_SERVICE` are on
  * This package is known to be broken on the AUR.
 * [cpp-jwt](https://github.com/arun11299/cpp-jwt) 1.4+ - if `ENABLE_WEB_SERVICE` is on
-* [unordered-dense](https://github.com/martinus/unordered_dense)

 On amd64:

@@ -119,7 +118,7 @@ Now, install all deps:
 sudo emerge -a \
    app-arch/lz4 app-arch/zstd app-arch/unzip \
    dev-libs/libfmt dev-libs/libusb dev-libs/mcl dev-libs/sirit \
-    dev-libs/unordered_dense dev-libs/boost dev-libs/openssl dev-libs/discord-rpc \
+    dev-libs/boost dev-libs/openssl dev-libs/discord-rpc \
    dev-util/spirv-tools dev-util/spirv-headers dev-util/vulkan-headers \
    dev-util/vulkan-utility-libraries dev-util/glslang \
    media-gfx/renderdoc media-libs/libva media-libs/opus media-video/ffmpeg \
@@ -260,7 +259,7 @@ brew install molten-vk
 <details>
 <summary>FreeBSD</summary>

-As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/unordered-dense vulkan-headers quazip-qt6`
+As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib vulkan-headers quazip-qt6`

 If using FreeBSD 12 or prior, use `devel/pkg-config` instead.

@@ -294,7 +293,7 @@ pkg_add cmake nasm git boost unzip--iconv autoconf-2.72p0 bash ffmpeg glslang gm
 <summary>DragonFlyBSD</summary>

 ```sh
-pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmake jq nlohmann-json enet spirv-tools sdl3 vulkan-utility-libraries vulkan-headers catch2 libfmt openssl liblz4 boost-libs cpp-httplib qt6-base qt6-charts quazip-qt6 unordered-dense libva-vdpau-driver libva-utils libva-intel-driver
+pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmake jq nlohmann-json enet spirv-tools sdl3 vulkan-utility-libraries vulkan-headers catch2 libfmt openssl liblz4 boost-libs cpp-httplib qt6-base qt6-charts quazip-qt6  libva-vdpau-driver libva-utils libva-intel-driver
 ```

 [Caveats](./Caveats.md#dragonflybsd).
@@ -328,7 +327,7 @@ sudo pkgin install git cmake autoconf build-essential libusb-1 nasm gcc13

 ```sh
 BASE="git make autoconf libtool automake-wrapper jq patch"
-MINGW="qt6-base qt6-charts qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet opus libusb unordered_dense openssl SDL3"
+MINGW="qt6-base qt6-charts qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet opus libusb openssl SDL3"
 # Either x86_64 or clang-aarch64 (Windows on ARM)
 packages="$BASE"
 for pkg in $MINGW; do
@@ -43,6 +43,7 @@ This guide will walk you through adding a new boolean toggle setting to Eden's c
 Firstly add your desired toggle:

 Example: `src/common/setting.h`
+
 ```cpp
 SwitchableSetting<bool> your_setting_name{linkage, false, "your_setting_name", Category::RendererExtensions};
 ```
@@ -67,6 +68,7 @@ Common Categories:
 Add the toggle to the Qt UI, where you wish for it to appear and place it there.

 Example: `src/qt_common/config/shared_translation.cpp`
+
 ```cpp
 INSERT(Settings,
       your_setting_name,
@@ -91,6 +93,7 @@ INSERT(Settings,
 Add where it should be in the settings.

 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt`
+
 ```kts
 RENDERER_YOUR_SETTING_NAME("your_setting_name"),
 ```
@@ -106,6 +109,7 @@ RENDERER_YOUR_SETTING_NAME("your_setting_name"),
 Add the toggle to the Kotlin (Android) UI

 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt`
+
 ```kts
 put(
    SwitchSetting(
@@ -123,6 +127,7 @@ put(
 Add your setting within the right category.

 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt`
+
 ```kts
 add(BooleanSetting.RENDERER_YOUR_SETTING_NAME.key)
 ```
@@ -137,6 +142,7 @@ add(BooleanSetting.RENDERER_YOUR_SETTING_NAME.key)
 Add your setting and description in the appropriate place.

 Example: `src/android/app/src/main/res/values/strings.xml`
+
 ```xml
 <string name="your_setting_name">Your Setting Display Name</string>
 <string name="your_setting_name_description">Detailed description of what this setting does. Explain any caveats, requirements, or warnings here.</string>
@@ -150,6 +156,7 @@ Now the UI part is done find a place in the code for the toggle,
 And use it to your heart's desire!

 Example:
+
 ```cpp
 const bool your_value = Settings::values.your_setting_name.GetValue();

@@ -196,25 +203,31 @@ Common advantages recap:

 #### Accessing Debug Knobs (dev side)

-Use the `Settings::getDebugKnobAt(u8 i)` function to check if a specific bit is set:
+Use the `Settings::GetDebugKnobAt(u8 i)` function to check if a specific bit is set:

 ```cpp
 //cpp side
 #include "common/settings.h"

+//To use it as a general purpose uint var:
+unsigned int debug_knobs = Settings::values.debug_knobs.GetValue();
+
 // Check if bit 0 is set
-bool feature_enabled = Settings::getDebugKnobAt(0);
+bool feature_enabled = Settings::GetDebugKnobAt(0);

 // Check if bit 15 is set
-bool another_feature = Settings::getDebugKnobAt(15);
+bool another_feature = Settings::GetDebugKnobAt(15);
 ```

 ```kts
 //kotlin side
 import org.yuzu.yuzu_emu.features.settings.model.Settings

+//To use it as a general purpose uint var
+val debug_knobs: Int = UShortSetting.DEBUG_KNOBS.getInt()
+
 // Check if bit x is set
-bool feature_enabled = Settings.getDebugKnobAt(x); //x as integer from 0 to 15
+bool feature_enabled = Settings.GetDebugKnobAt(x); //x as integer from 0 to 15
 ```

 The function returns `true` if the specified bit (0-15) is set in the `debug_knobs` value, `false` otherwise.
@@ -247,6 +260,7 @@ There are two main confusions when talking about knobs:
 Sometimes when an user reports: knobs 1 and 2 gets better performance, dev may get confuse whether he means the knobs 1 and 2 literally, or the 1st and 2nd knobs (knobs 0 and 1).

 Debug knobs are **zero-based**, which means:
+
 * The first knob is the knob(0) (or knob0 henceforth), and the last one is the 15 (knob15, likewise)
 * You can talk: "knob0 is enabled/disabled", "In this video i was using only knobs 0 and 2", etc.

@@ -259,6 +273,7 @@ Whenever you're instructing tests or reporting results, be precise about whether

 ALWAYS use the word in PLURAL (knobs), without mentioning which one, to refer to the setting, aka multiple knobs at once:
 Examples:
+
 - **knobs=0**: no knobs enabled
 - **knobs=1**: knob0 enabled, others disabled
 - **knobs=2**: knob1 enabled, others disabled
@@ -270,6 +285,7 @@ Examples:

 Use the word in SINGULAR (knob), or in plural but referring which ones, when meaning multiple knobs at once:
 Examples:
+
 - **knob0**: knob 0 enabled, others disabled
 - **knob1**: knob 1 enabled, others disabled
 - **knobs 0 and 1**: knobs 0 and 1 enabled, others disabled
@@ -282,12 +298,12 @@ Examples:

 ```cpp
 void SomeFunction() {
-    if (Settings::getDebugKnobAt(0)) {
+    if (Settings::GetDebugKnobAt(0)) {
        LOG_DEBUG(Common, "Debug feature 0 is enabled");
        // Additional debug code here
    }
-    
-    if (Settings::getDebugKnobAt(1)) {
+  
+    if (Settings::GetDebugKnobAt(1)) {
        LOG_DEBUG(Common, "Debug feature 1 is enabled");
        // Different debug behavior
    }
@@ -299,7 +315,7 @@ void SomeFunction() {
 ```cpp
 bool UseOptimizedPath() {
    // Skip optimization if debug bit 2 is set for testing
-    return !Settings::getDebugKnobAt(2);
+    return !Settings::GetDebugKnobAt(2);
 }
 ```

@@ -308,13 +324,13 @@ bool UseOptimizedPath() {
 ```cpp
 void ExperimentalFeature() {
    static constexpr u8 EXPERIMENTAL_FEATURE_BIT = 3;
-    
-    if (!Settings::getDebugKnobAt(EXPERIMENTAL_FEATURE_BIT)) {
+  
+    if (!Settings::GetDebugKnobAt(EXPERIMENTAL_FEATURE_BIT)) {
        // Fallback to stable implementation
        StableImplementation();
        return;
    }
-    
+  
    // Experimental implementation
    ExperimentalImplementation();
 }
@@ -308,31 +308,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```

-### unordered_dense
-
-```
-MIT License
-
-Copyright (c) 2022 Martin Leitner-Ankerl
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```

 ### xbyak

@@ -58,9 +58,6 @@ if (WIN32 AND NOT TARGET LLVM::Demangle)
    add_library(LLVM::Demangle ALIAS demangle)
 endif()

-# unordered_dense
-AddJsonPackage(unordered-dense)
-
 # httplib
 if (IOS)
    set(HTTPLIB_USE_BROTLI_IF_AVAILABLE OFF)
@@ -220,7 +220,7 @@ object NativeLibrary {

    external fun refreshThreadPolicies()

-    external fun getDebugKnobAt(index: Int): Boolean
+    external fun GetDebugKnobAt(index: Int): Boolean

    /**
     * Set the current speed limit to the configured turbo speed.
@@ -35,8 +35,8 @@ object Settings {
    fun getPlayerString(player: Int): String =
        YuzuApplication.appContext.getString(R.string.preferences_player, player)

-    fun getDebugKnobAt(index: Int): Boolean {
-        return org.yuzu.yuzu_emu.NativeLibrary.getDebugKnobAt(index)
+    fun GetDebugKnobAt(index: Int): Boolean {
+        return org.yuzu.yuzu_emu.NativeLibrary.GetDebugKnobAt(index)
    }

    const val PREF_FIRST_APP_LAUNCH = "FirstApplicationLaunch"
@@ -11,8 +11,7 @@ import org.yuzu.yuzu_emu.utils.NativeConfig
 enum class ShortSetting(override val key: String) : AbstractShortSetting {
    RENDERER_SPEED_LIMIT("speed_limit"),
    RENDERER_TURBO_SPEED_LIMIT("turbo_speed_limit"),
-    RENDERER_SLOW_SPEED_LIMIT("slow_speed_limit"),
-    DEBUG_KNOBS("debug_knobs")
+    RENDERER_SLOW_SPEED_LIMIT("slow_speed_limit")
    ;

    override fun getShort(needsGlobal: Boolean): Short = NativeConfig.getShort(key, needsGlobal)
@@ -29,4 +28,4 @@ enum class ShortSetting(override val key: String) : AbstractShortSetting {
    override fun getValueAsString(needsGlobal: Boolean): String = getShort(needsGlobal).toString()

    override fun reset() = NativeConfig.setShort(key, defaultValue)
-}
+}
@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.features.settings.model
+
+import org.yuzu.yuzu_emu.utils.NativeConfig
+
+enum class UShortSetting(override val key: String) : AbstractIntSetting {
+    DEBUG_KNOBS("debug_knobs")
+    ;
+
+    override fun getInt(needsGlobal: Boolean): Int =
+        NativeConfig.getUnsignedShort(key, needsGlobal)
+
+    override fun setInt(value: Int) {
+        if (NativeConfig.isPerGameConfigLoaded()) {
+            global = false
+        }
+        NativeConfig.setUnsignedShort(key, value)
+    }
+
+    override val defaultValue: Int by lazy { NativeConfig.getDefaultToString(key).toInt() }
+
+    override fun getValueAsString(needsGlobal: Boolean): String = getInt(needsGlobal).toString()
+
+    override fun reset() = NativeConfig.setUnsignedShort(key, defaultValue)
+}
@@ -20,6 +20,7 @@ import org.yuzu.yuzu_emu.features.settings.model.IntSetting
 import org.yuzu.yuzu_emu.features.settings.model.LongSetting
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
+import org.yuzu.yuzu_emu.features.settings.model.UShortSetting
 import org.yuzu.yuzu_emu.network.NetDataValidators
 import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
 import org.yuzu.yuzu_emu.utils.NativeConfig
@@ -1034,7 +1035,7 @@ abstract class SettingsItem(
            )
            put(
                SpinBoxSetting(
-                    ShortSetting.DEBUG_KNOBS,
+                    UShortSetting.DEBUG_KNOBS,
                    titleId = R.string.debug_knobs,
                    descriptionId = R.string.debug_knobs_description,
                    valueHint = R.string.debug_knobs_hint,
@@ -25,6 +25,7 @@ import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.features.settings.model.Settings.MenuTag
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
+import org.yuzu.yuzu_emu.features.settings.model.UShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.view.*
 import org.yuzu.yuzu_emu.utils.InputHandler
 import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
@@ -1326,7 +1327,7 @@ class SettingsFragmentPresenter(

            add(HeaderSetting(R.string.general))

-            add(ShortSetting.DEBUG_KNOBS.key)
+            add(UShortSetting.DEBUG_KNOBS.key)
            add(StringSetting.PROGRAM_ARGS.key)

            if (!NativeConfig.isPerGameConfigLoaded()) {
@@ -80,6 +80,12 @@ object NativeConfig {
    @Synchronized
    external fun setShort(key: String, value: Short)

+    @Synchronized
+    external fun getUnsignedShort(key: String, needsGlobal: Boolean): Int
+
+    @Synchronized
+    external fun setUnsignedShort(key: String, value: Int)
+
    @Synchronized
    external fun getInt(key: String, needsGlobal: Boolean): Int

@@ -20,7 +20,7 @@ struct RomMetadata {
    std::vector<u8> icon;
    bool isHomebrew;
 };
-static ankerl::unordered_dense::map<std::string, RomMetadata> m_rom_metadata_cache;
+static boost::unordered::unordered_flat_map<std::string, RomMetadata> m_rom_metadata_cache;

 static RomMetadata CacheRomMetadata(const std::string& path) {
    auto& instance = EmulationSession::GetInstance();
@@ -1300,8 +1300,8 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_refreshThreadPolicies(JNIEnv* env, jo
    Common::RefreshThreadPolicies();
 }

-jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_getDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {
-    return static_cast<jboolean>(Settings::getDebugKnobAt(static_cast<u8>(index)));
+jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_GetDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {
+    return static_cast<jboolean>(Settings::GetDebugKnobAt(static_cast<u8>(index)));
 }

 void Java_org_yuzu_yuzu_1emu_NativeLibrary_setTurboSpeedLimit(JNIEnv *env, jobject jobj, jboolean enabled) {
@@ -130,6 +130,25 @@ void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_setShort(JNIEnv* env, jobject ob
    setting->SetValue(value);
 }

+jint Java_org_yuzu_yuzu_1emu_utils_NativeConfig_getUnsignedShort(JNIEnv* env, jobject obj,
+                                                                 jstring jkey,
+                                                                 jboolean needGlobal) {
+    auto setting = getSetting<u16>(env, jkey);
+    if (setting == nullptr) {
+        return -1;
+    }
+    return static_cast<jint>(setting->GetValue(static_cast<bool>(needGlobal)));
+}
+
+void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_setUnsignedShort(JNIEnv* env, jobject obj,
+                                                                  jstring jkey, jint value) {
+    auto setting = getSetting<u16>(env, jkey);
+    if (setting == nullptr) {
+        return;
+    }
+    setting->SetValue(static_cast<u16>(value));
+}
+
 jint Java_org_yuzu_yuzu_1emu_utils_NativeConfig_getInt(JNIEnv* env, jobject obj, jstring jkey,
                                                       jboolean needGlobal) {
    auto setting = getSetting<int>(env, jkey);
@@ -21,7 +21,7 @@
 #include "input_common/drivers/virtual_gamepad.h"
 #include "native.h"

-ankerl::unordered_dense::map<std::string, std::unique_ptr<AndroidConfig>> map_profiles;
+boost::unordered::unordered_flat_map<std::string, std::unique_ptr<AndroidConfig>> map_profiles;

 bool IsHandheldOnly() {
    const auto npad_style_set =
@@ -241,7 +241,7 @@ if (lz4_ADDED)
    target_include_directories(common PRIVATE ${lz4_SOURCE_DIR}/lib)
 endif()

-target_link_libraries(common PUBLIC fmt::fmt stb::headers Threads::Threads unordered_dense::unordered_dense)
+target_link_libraries(common PUBLIC fmt::fmt stb::headers Threads::Threads)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd)

 # Please refer to src/common/demangle.cpp
@@ -7,7 +7,8 @@
 #include <algorithm>
 #include <iostream>
 #include <sstream>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/assert.h"
 #include "common/fs/fs.h"
@@ -196,8 +197,8 @@ private:
        SetLegacyPathImpl(legacy_path, new_path);
    }

-    ankerl::unordered_dense::map<EdenPath, fs::path> eden_paths;
-    ankerl::unordered_dense::map<EmuPath, fs::path> legacy_paths;
+    boost::unordered::unordered_flat_map<EdenPath, fs::path> eden_paths;
+    boost::unordered::unordered_flat_map<EmuPath, fs::path> legacy_paths;
 };

 bool ValidatePath(const fs::path& path) {
@@ -7,7 +7,8 @@
 #ifdef _WIN32

 #include <iterator>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/icl/separate_interval_set.hpp>
 #include <windows.h>
 #include "common/dynamic_library.h"
@@ -391,7 +392,7 @@ private:

    std::mutex placeholder_mutex;                                 ///< Mutex for placeholders
    boost::icl::separate_interval_set<size_t> placeholders;       ///< Mapped placeholders
-    ankerl::unordered_dense::map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
+    boost::unordered::unordered_flat_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
 };

 #elif defined(__OPENORBIS__) || defined(__managarm__)
@@ -9,7 +9,8 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <utility>
 #include <vector>
 #include "common/logging.h"
@@ -412,7 +413,7 @@ public:
 namespace Impl {

 template <typename InputDeviceType>
-using FactoryListType = ankerl::unordered_dense::map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
+using FactoryListType = boost::unordered::unordered_flat_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;

 template <typename InputDeviceType>
 struct FactoryList {
@@ -329,7 +329,7 @@ struct LogcatBackend : public Backend {
            }
        }();
        auto const df = GetDirectFormatArgs(entry);
-        __android_log_print(android_log_priority, "YuzuNative", CCB_PRINTF_FMT, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
+        __android_log_print(android_log_priority, "YuzuNative", "%s %s:%u:%s: %s", df.class_name, entry.filename, entry.line_num, entry.function, entry.message);
    }
    void Flush() noexcept override {}
 };
@@ -428,21 +428,33 @@ void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename, u
        auto const flush = ::Settings::values.log_flush_line.GetValue();
        char buffer[BUFSIZ];
        auto result = fmt::vformat_to_n(buffer, sizeof(buffer) - 1, format, args);
-        buffer[(std::min)(result.size, sizeof(buffer) - 1)] = '\0';
-        logging_instance->ForEachBackend([=](Backend& backend) {
-            backend.Write(Entry{
-                .message = buffer,
-                .message_len = (std::min)(result.size, sizeof(buffer) - 1),
-                .timestamp = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - logging_instance->time_origin),
-                .log_class = log_class,
-                .log_level = log_level,
-                .filename = TrimSourcePath(filename),
-                .function = function,
-                .line_num = line_num,
+        Entry e{
+            .message = nullptr,
+            .message_len = 0,
+            .timestamp = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - logging_instance->time_origin),
+            .log_class = log_class,
+            .log_level = log_level,
+            .filename = TrimSourcePath(filename),
+            .function = function,
+            .line_num = line_num,
+        };
+        if (result.size <= sizeof(buffer) - 1) {
+            buffer[(std::min)(result.size, sizeof(buffer) - 1)] = '\0';
+            e.message = buffer;
+            e.message_len = (std::min)(result.size, sizeof(buffer) - 1);
+            logging_instance->ForEachBackend([=](Backend& backend) {
+                backend.Write(e);
+                if (flush) backend.Flush();
            });
-            if (flush)
-                backend.Flush();
-        });
+        } else {
+            std::string s = fmt::vformat(format, args);
+            e.message = s.c_str();
+            e.message_len = s.size();
+            logging_instance->ForEachBackend([=](Backend& backend) {
+                backend.Write(e);
+                if (flush) backend.Flush();
+            });
+        }
    }
 }
 } // namespace Common::Log
@@ -8,14 +8,15 @@

 #include <initializer_list>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 namespace Common {

 /// A string-based key-value container supporting serializing to and deserializing from a string
 class ParamPackage {
 public:
-    using DataType = ankerl::unordered_dense::map<std::string, std::string>;
+    using DataType = boost::unordered::unordered_flat_map<std::string, std::string>;

    ParamPackage() = default;
    explicit ParamPackage(const std::string& serialized);
@@ -126,9 +126,9 @@ void LogSettings() {
                    setting->UsingGlobal() ? '-' : 'C', TranslateCategory(category),
                    setting->GetLabel());
                if (is_default)
-                    settings_list.push_back(fmt::format("{}: {}\n", name, setting->Canonicalize()));
+                    settings_list.push_back(fmt::format("{}: {}", name, setting->Canonicalize()));
                else
-                    settings_list.push_front(fmt::format("{}: {}\n", name, setting->Canonicalize()));
+                    settings_list.push_front(fmt::format("{}: {}", name, setting->Canonicalize()));
            }
        }
    }
@@ -146,7 +146,7 @@ void LogSettings() {
 #undef LOG_PATH
 }

-bool getDebugKnobAt(u8 i) {
+bool GetDebugKnobAt(u8 i) {
    return (values.debug_knobs.GetValue() & (1 << (i & 0xF))) != 0;
 }

@@ -904,7 +904,7 @@ struct Values {
                                           0,
                                           65535,
                                           "debug_knobs",
-                                           Category::Debugging,
+                                           Category::System,
                                           Specialization::Countable,
                                           true,
                                           true};
@@ -947,7 +947,7 @@ constexpr u32 MAX_FRAME_GEN_MULTIPLIER = 4;

 [[nodiscard]] size_t FrameGenMaxGenerations();

-bool getDebugKnobAt(u8 i);
+bool GetDebugKnobAt(u8 i);

 void UpdateGPUAccuracy();
 bool IsGPULevelHigh();
@@ -22,10 +22,11 @@
 #endif

 // You must ensure this matches with src/common/x64/xbyak.h on root dir
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/unordered_map.hpp>
-#define XBYAK_STD_UNORDERED_SET ankerl::unordered_dense::set
-#define XBYAK_STD_UNORDERED_MAP ankerl::unordered_dense::map
+#define XBYAK_STD_UNORDERED_SET boost::unordered::unordered_flat_set
+#define XBYAK_STD_UNORDERED_MAP boost::unordered::unordered_flat_map
 #define XBYAK_STD_UNORDERED_MULTIMAP boost::unordered_multimap
 #include <xbyak/xbyak.h>
 #include <xbyak/xbyak_util.h>
@@ -8,7 +8,8 @@

 #include <atomic>
 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include <dynarmic/interface/A64/a64.h>
 #include <dynarmic/interface/code_page.h>
@@ -4,7 +4,7 @@
 #pragma once

 #include <span>
-#include <ankerl/unordered_dense.h>
+#include <boost/container/flat_map.hpp>
 #include <vector>
 #include <oaknut/code_block.hpp>
 #include <oaknut/oaknut.hpp>
@@ -46,7 +46,7 @@ enum class PatchMode : u32 {

 using ModuleTextAddress = u64;
 using PatchTextAddress = u64;
-using EntryTrampolines = ankerl::unordered_dense::map<ModuleTextAddress, PatchTextAddress>;
+using EntryTrampolines = boost::container::flat_map<ModuleTextAddress, PatchTextAddress>;

 class Patcher {
 public:
@@ -3,10 +3,13 @@

 #include <algorithm>
 #include <cstring>
-#include <map>
 #include <sstream>
 #include <string>
 #include <utility>
+#include <span>
+#include <cctype>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/hex_util.h"
 #include "common/logging.h"
@@ -22,61 +25,30 @@ enum class IPSFileType {
    Error,
 };

-constexpr std::array<std::pair<const char*, const char*>, 11> ESCAPE_CHARACTER_MAP{{
-    {"\\a", "\a"},
-    {"\\b", "\b"},
-    {"\\f", "\f"},
-    {"\\n", "\n"},
-    {"\\r", "\r"},
-    {"\\t", "\t"},
-    {"\\v", "\v"},
-    {"\\\\", "\\"},
-    {"\\\'", "\'"},
-    {"\\\"", "\""},
-    {"\\\?", "\?"},
-}};
-
-static IPSFileType IdentifyMagic(const std::vector<u8>& magic) {
-    if (magic.size() != 5) {
-        return IPSFileType::Error;
+static IPSFileType IdentifyMagic(std::span<const u8> magic) {
+    if (magic.size() >= 5) {
+        if (std::memcmp(magic.data(), "PATCH", 5) == 0)
+            return IPSFileType::IPS;
+        if (std::memcmp(magic.data(), "IPS32", 5) == 0)
+            return IPSFileType::IPS32;
    }
-
-    static constexpr std::array<u8, 5> patch_magic{{'P', 'A', 'T', 'C', 'H'}};
-    if (std::equal(magic.begin(), magic.end(), patch_magic.begin())) {
-        return IPSFileType::IPS;
-    }
-
-    static constexpr std::array<u8, 5> ips32_magic{{'I', 'P', 'S', '3', '2'}};
-    if (std::equal(magic.begin(), magic.end(), ips32_magic.begin())) {
-        return IPSFileType::IPS32;
-    }
-
    return IPSFileType::Error;
 }

-static bool IsEOF(IPSFileType type, const std::vector<u8>& data) {
-    static constexpr std::array<u8, 3> eof{{'E', 'O', 'F'}};
-    if (type == IPSFileType::IPS && std::equal(data.begin(), data.end(), eof.begin())) {
-        return true;
-    }
-
-    static constexpr std::array<u8, 4> eeof{{'E', 'E', 'O', 'F'}};
-    return type == IPSFileType::IPS32 && std::equal(data.begin(), data.end(), eeof.begin());
+static bool IsEOF(IPSFileType type, std::span<const u8> magic) {
+    return (type == IPSFileType::IPS && magic.size() > 3 && std::memcmp(magic.data(), "EOF", 3) == 0)
+        || (type == IPSFileType::IPS32 && magic.size() > 4 && std::memcmp(magic.data(), "EEOF", 4) == 0);
 }

 VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
    if (in == nullptr || ips == nullptr)
        return nullptr;

-    const auto type = IdentifyMagic(ips->ReadBytes(0x5));
+    auto in_data = in->ReadAllBytes();
+    auto const type = IdentifyMagic(in_data);
    if (type == IPSFileType::Error)
        return nullptr;

-    auto in_data = in->ReadAllBytes();
-    if (in_data.size() == 0) {
-        return nullptr;
-    }
-
    std::vector<u8> temp(type == IPSFileType::IPS ? 3 : 4);
    u64 offset = 5; // After header
    while (ips->Read(temp.data(), temp.size(), offset) == temp.size()) {
@@ -85,12 +57,9 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
            break;
        }

-        u32 real_offset{};
-        if (type == IPSFileType::IPS32)
-            real_offset = (temp[0] << 24) | (temp[1] << 16) | (temp[2] << 8) | temp[3];
-        else
-            real_offset = (temp[0] << 16) | (temp[1] << 8) | temp[2];
-
+        u32 real_offset = (type == IPSFileType::IPS32)
+            ? ((temp[0] << 24) | (temp[1] << 16) | (temp[2] << 8) | temp[3])
+            : ((temp[0] << 16) | (temp[1] << 8) | temp[2]);
        if (real_offset > in_data.size()) {
            return nullptr;
        }
@@ -113,34 +82,35 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
                return nullptr;

            if (real_offset + rle_size > in_data.size())
-                rle_size = static_cast<u16>(in_data.size() - real_offset);
+                rle_size = u16(in_data.size() - real_offset);
            std::memset(in_data.data() + real_offset, *data, rle_size);
        } else { // Standard Patch
            auto read = data_size;
            if (real_offset + read > in_data.size())
-                read = static_cast<u16>(in_data.size() - real_offset);
+                read = u16(in_data.size() - real_offset);
            if (ips->Read(in_data.data() + real_offset, read, offset) != data_size)
                return nullptr;
            offset += data_size;
        }
    }
-
-    if (!IsEOF(type, temp)) {
-        return nullptr;
+    if (IsEOF(type, temp)) {
+        return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(), in->GetContainingDirectory());
    }
-
-    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
-                                           in->GetContainingDirectory());
+    return nullptr;
 }

+
+struct IPSwitchRecord {
+    std::array<uint8_t, 256 - sizeof(size_t)> data;
+    size_t count;
+};
 struct IPSwitchCompiler::IPSwitchPatch {
-    std::string name;
+    boost::unordered::unordered_flat_map<u32, IPSwitchRecord> records;
    bool enabled;
-    std::map<u32, std::vector<u8>> records;
 };

 IPSwitchCompiler::IPSwitchCompiler(VirtualFile patch_text_) : patch_text(std::move(patch_text_)) {
-    Parse();
+    Parse(patch_text->ReadAllBytes());
 }

 IPSwitchCompiler::~IPSwitchCompiler() = default;
@@ -149,201 +119,159 @@ std::array<u8, 32> IPSwitchCompiler::GetBuildID() const {
    return nso_build_id;
 }

-bool IPSwitchCompiler::IsValid() const {
-    return valid;
-}
-
-static bool StartsWith(std::string_view base, std::string_view check) {
-    return base.size() >= check.size() && base.substr(0, check.size()) == check;
-}
-
-static std::string EscapeStringSequences(std::string in) {
-    for (const auto& seq : ESCAPE_CHARACTER_MAP) {
-        for (auto index = in.find(seq.first); index != std::string::npos;
-             index = in.find(seq.first, index)) {
-            in.replace(index, std::strlen(seq.first), seq.second);
-            index += std::strlen(seq.second);
+static IPSwitchRecord EscapeStringSequences(std::string_view sv) {
+    IPSwitchRecord r{};
+    for (auto it = sv.cbegin(); it != sv.cend(); ) {
+        if (*it == '\\' && it + 1 < sv.cend()) {
+            switch (it[1]) {
+            case 'n': r.data[r.count] = '\n'; break;
+            case 't': r.data[r.count] = '\t'; break;
+            case 'b': r.data[r.count] = '\b'; break;
+            case 'r': r.data[r.count] = '\r'; break;
+            case 'e': r.data[r.count] = '\e'; break;
+            case 'v': r.data[r.count] = '\v'; break;
+            case '?': r.data[r.count] = '\?'; break;
+            default: r.data[r.count] = it[1]; break;
+            }
+            ++r.count;
+            it += 2;
+        } else {
+            ++r.count;
+            ++it;
        }
    }
-
-    return in;
+    return r;
 }

-void IPSwitchCompiler::ParseFlag(const std::string& line) {
-    if (StartsWith(line, "@flag offset_shift ")) {
-        // Offset Shift Flag
-        offset_shift = std::strtoll(line.substr(19).c_str(), nullptr, 0);
-    } else if (StartsWith(line, "@little-endian")) {
-        // Set values to read as little endian
-        is_little_endian = true;
-    } else if (StartsWith(line, "@big-endian")) {
-        // Set values to read as big endian
-        is_little_endian = false;
-    } else if (StartsWith(line, "@flag print_values")) {
-        // Force printing of applied values
-        print_values = true;
-    }
+[[nodiscard]] static inline std::array<u8, 32> ReadNSOBuildId(std::string_view const s) {
+    std::array<u8, 32> r{};
+    for (std::size_t i = 0; i < s.size(); ++i)
+        r[i / 2] |= u8(u8(Common::ToHexNibble(s[i])) << u8((i % 2) * 4));
+    return r;
 }

-void IPSwitchCompiler::Parse() {
-    const auto bytes = patch_text->ReadAllBytes();
-    std::stringstream s;
-    s.write(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
+    LOG_INFO(Loader, "IPSwitchCompiler: '{}'", patch_text->GetName());
+    bool is_little_endian = false;
+    s64 offset_shift = 0;
+    //bool print_values = false;

-    std::vector<std::string> lines;
-    std::string stream_line;
-    while (std::getline(s, stream_line)) {
-        // Remove a trailing \r
-        if (!stream_line.empty() && stream_line.back() == '\r')
-            stream_line.pop_back();
-        lines.push_back(std::move(stream_line));
-    }
+    auto const parse_line = [&](std::string_view const line) {
+        // Keep in mind lines have trimmed spaces (at the end & start)!
+        LOG_INFO(Loader, "<{}>", line);
+        if (line.starts_with("@stop")) {
+            return false; // Force stop
+        } else if (line.starts_with("@nsobid-")) { // NSO Build ID Specifier
+            nso_build_id = ReadNSOBuildId(line.substr(8));
+        } else if (line.starts_with("@enabled")) {
+            patches.push_back({{}, true}); //enabled patch
+        } else if (line.starts_with("@disabled")) {
+            patches.push_back({{}, false}); //disabled patch
+        } else if (line.starts_with("@flag offset_shift ")) {
+            offset_shift = std::strtoll(line.data() + 19, nullptr, 0);  // Offset Shift Flag
+        } else if (line.starts_with("@little-endian")) {
+            is_little_endian = true;  // Set values to read as little endian
+        } else if (line.starts_with("@big-endian")) {
+            is_little_endian = false;  // Set values to read as big endian
+        } else if (line.starts_with("@flag print_values")) {
+            //print_values = true; // Force printing of applied values
+        } else if (line.starts_with("@")) {
+            LOG_WARNING(Loader, "Unknown flag {}", line);
+        } else {
+            size_t offset = size_t(std::strtoul(line.data(), nullptr, 16));
+            offset += size_t(offset_shift);
+            if (auto const first_quote = line.find_first_of("\"\'"); first_quote != std::string::npos) {
+                // string replacement
+                char quote = line[first_quote];
+                auto const start = line.cbegin() + first_quote + 1;
+                auto end = start;
+                for (; end < line.cend() && *end != quote; )
+                    end += (*end == '\\') ? 2 : 1;
+                if (start <= line.cend() && end <= line.cend()) {
+                    LOG_INFO(Loader, "[S] value @ {:#08X} ", offset);
+                    patches.back().records.insert_or_assign(u32(offset), EscapeStringSequences({start, end}));
+                } else {
+                    LOG_WARNING(Loader, "invalid string");
+                }
+            } else if (auto const first_space = line.find_last_of(" /\t\r\n"); first_space != std::string::npos) {
+                IPSwitchRecord r{}; // hex replacement
+                auto const start = line.cbegin() + first_space + 1;
+                auto const end = line.cend();
+                if (start <= line.cend() && end <= line.cend()) {
+                    auto const hs = Common::HexStringToVector({start, end}, is_little_endian);
+                    std::memcpy(r.data.data(), hs.data(), hs.size());
+                    r.count = hs.size();
+                    LOG_INFO(Loader, "[H] value @ {:#08X}", offset);
+                    patches.back().records.insert_or_assign(u32(offset), std::move(r));
+                } else {
+                    LOG_WARNING(Loader, "invalid line");
+                }
+            } else {
+                LOG_WARNING(Loader, "unhandled line!");
+            }
+        }
+        return true; //continue
+    };

-    for (std::size_t i = 0; i < lines.size(); ++i) {
-        auto line = lines[i];
-
-        // Remove midline comments
-        std::size_t comment_index = std::string::npos;
-        bool within_string = false;
-        for (std::size_t k = 0; k < line.size(); ++k) {
-            if (line[k] == '\"' && (k > 0 && line[k - 1] != '\\')) {
-                within_string = !within_string;
-            } else if (line[k] == '\\' && (k < line.size() - 1 && line[k + 1] == '\\')) {
-                comment_index = k;
+    for (auto it = bytes.begin(); it < bytes.end(); ) {
+        auto const start = it;
+        auto end = start;
+        for (; end < bytes.end() && *end != '\n' && *end != '\r'; ++end)
+            ;
+        it = end + 1; //prepare for next line
+        std::string_view const sline{
+            reinterpret_cast<const char*>(bytes.data() + std::distance(bytes.begin(), start)),
+            size_t(std::distance(start, end))
+        };
+        if (sline.size() > 0) {
+            auto p = sline.cbegin();
+            // skip space off line
+            for (; p < sline.cend() && std::isspace(*p); ++p)
+                ;
+            // now make a nominal preprocessed line: remove comments
+            char quote = '\0';
+            auto const sline_start = p;
+            for (; p < sline.cend(); ) {
+                if ((!quote && p + 1 < sline.cend() && p[0] == '/' && p[1] == '/')
+                || (!quote && p[0] == '#')) {
+                    break;
+                } else if (p[0] == '\"' || p[0] == '\'') {
+                    quote = (p[0] == quote) ? '\0' : p[0];
+                    ++p;
+                } else if (p + 1 < sline.cend() && p[0] == '\\') {
+                    p += 2;
+                } else {
+                    ++p;
+                }
+            }
+            // now we have the preprocessed string ;)
+            std::string_view pp_str(sline_start, p);
+            if (pp_str.size() > 0 && !parse_line(pp_str)) {
                break;
            }
        }
-
-        if (!StartsWith(line, "//") && comment_index != std::string::npos) {
-            last_comment = line.substr(comment_index + 2);
-            line = line.substr(0, comment_index);
-        }
-
-        if (StartsWith(line, "@stop")) {
-            // Force stop
-            break;
-        } else if (StartsWith(line, "@nsobid-")) {
-            // NSO Build ID Specifier
-            const auto raw_build_id = fmt::format("{:0<64}", line.substr(8));
-            nso_build_id = Common::HexStringToArray<0x20>(raw_build_id);
-        } else if (StartsWith(line, "#")) {
-            // Mandatory Comment
-            LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Forced output comment: {}",
-                     patch_text->GetName(), line.substr(1));
-        } else if (StartsWith(line, "//")) {
-            // Normal Comment
-            last_comment = line.substr(2);
-            if (last_comment.find_first_not_of(' ') == std::string::npos)
-                continue;
-            if (last_comment.find_first_not_of(' ') != 0)
-                last_comment = last_comment.substr(last_comment.find_first_not_of(' '));
-        } else if (StartsWith(line, "@enabled") || StartsWith(line, "@disabled")) {
-            // Start of patch
-            const auto enabled = StartsWith(line, "@enabled");
-            if (i == 0)
-                return;
-            LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Parsing patch '{}' ({})",
-                     patch_text->GetName(), last_comment, line.substr(1));
-
-            IPSwitchPatch patch{last_comment, enabled, {}};
-
-            // Read rest of patch
-            while (true) {
-                if (i + 1 >= lines.size()) {
-                    break;
-                }
-
-                const auto& patch_line = lines[++i];
-
-                // Patch line may contain comments
-                if (StartsWith(patch_line, "//") || StartsWith(patch_line, "#")) {
-                    continue;
-                }
-
-                // Start of new patch
-                if (StartsWith(patch_line, "@enabled") || StartsWith(patch_line, "@disabled")) {
-                    --i;
-                    break;
-                }
-
-                // Check for a flag
-                if (StartsWith(patch_line, "@")) {
-                    ParseFlag(patch_line);
-                    continue;
-                }
-
-                // 11 - 8 hex digit offset + space + minimum two digit overwrite val
-                if (patch_line.length() < 11)
-                    break;
-                auto offset = std::strtoul(patch_line.substr(0, 8).c_str(), nullptr, 16);
-                offset += static_cast<unsigned long>(offset_shift);
-
-                std::vector<u8> replace;
-                // 9 - first char of replacement val
-                if (patch_line[9] == '\"') {
-                    // string replacement
-                    auto end_index = patch_line.find('\"', 10);
-                    if (end_index == std::string::npos || end_index < 10)
-                        return;
-                    while (patch_line[end_index - 1] == '\\') {
-                        end_index = patch_line.find('\"', end_index + 1);
-                        if (end_index == std::string::npos || end_index < 10)
-                            return;
-                    }
-
-                    auto value = patch_line.substr(10, end_index - 10);
-                    value = EscapeStringSequences(value);
-                    replace.reserve(value.size());
-                    std::copy(value.begin(), value.end(), std::back_inserter(replace));
-                } else {
-                    // hex replacement
-                    const auto value =
-                        patch_line.substr(9, patch_line.find_first_of(" /\r\n", 9) - 9);
-                    replace = Common::HexStringToVector(value, is_little_endian);
-                }
-
-                if (print_values) {
-                    LOG_INFO(Loader,
-                             "[IPSwitchCompiler ('{}')]     - Patching value at offset {:#08x} "
-                             "with byte string '{}'",
-                             patch_text->GetName(), offset, Common::HexToString(replace));
-                }
-
-                patch.records.insert_or_assign(static_cast<u32>(offset), std::move(replace));
-            }
-
-            patches.push_back(std::move(patch));
-        } else if (StartsWith(line, "@")) {
-            ParseFlag(line);
-        }
    }
-
-    valid = true;
 }

 VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
-    if (in == nullptr || !valid)
+    if (in == nullptr)
        return nullptr;

    auto in_data = in->ReadAllBytes();

    for (const auto& patch : patches) {
-        if (!patch.enabled)
-            continue;
-
-        for (const auto& record : patch.records) {
-            if (record.first >= in_data.size())
-                continue;
-            auto replace_size = record.second.size();
-            if (record.first + replace_size > in_data.size())
-                replace_size = in_data.size() - record.first;
-            for (std::size_t i = 0; i < replace_size; ++i)
-                in_data[i + record.first] = record.second[i];
+        if (patch.enabled) {
+            for (const auto& record : patch.records) {
+                if (record.first < in_data.size()) {
+                    auto replace_size = record.second.count;
+                    if (record.first + replace_size > in_data.size())
+                        replace_size = in_data.size() - record.first;
+                    std::memcpy(in_data.data() + record.first, record.second.data.data(), replace_size);
+                }
+            }
        }
    }
-
-    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
-                                           in->GetContainingDirectory());
+    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(), in->GetContainingDirectory());
 }

 } // namespace FileSys
@@ -1,11 +1,14 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

 #include <array>
-#include <memory>
 #include <vector>
+#include <span>

 #include "common/common_types.h"
 #include "core/file_sys/vfs/vfs.h"
@@ -20,24 +23,17 @@ public:
    ~IPSwitchCompiler();

    std::array<u8, 0x20> GetBuildID() const;
-    bool IsValid() const;
    VirtualFile Apply(const VirtualFile& in) const;

 private:
    struct IPSwitchPatch;

    void ParseFlag(const std::string& flag);
-    void Parse();
-
-    bool valid = false;
+    void Parse(std::span<u8 const> bytes);

    VirtualFile patch_text;
    std::vector<IPSwitchPatch> patches;
    std::array<u8, 0x20> nso_build_id{};
-    bool is_little_endian = false;
-    s64 offset_shift = 0;
-    bool print_values = false;
-    std::string last_comment = "";
 };

 } // namespace FileSys
@@ -345,8 +345,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    return exefs;
 }

-std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                                      const std::string& build_id) const {
+std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs, const std::string& build_id) const {
    const auto& disabled = Settings::values.disabled_addons[title_id];
    const auto nso_build_id = fmt::format("{:0<64}", build_id);

@@ -361,16 +360,11 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
            for (const auto& file : exefs_dir->GetFiles()) {
                if (file->GetExtension() == "ips") {
                    auto name = file->GetName();
-
-                    const auto this_build_id =
-                        fmt::format("{:0<64}", name.substr(0, name.find('.')));
+                    const auto this_build_id = fmt::format("{:0<64}", name.substr(0, name.find('.')));
                    if (nso_build_id == this_build_id)
                        out.push_back(file);
                } else if (file->GetExtension() == "pchtxt") {
                    IPSwitchCompiler compiler{file};
-                    if (!compiler.IsValid())
-                        continue;
-
                    const auto this_build_id = Common::HexToString(compiler.GetBuildID());
                    if (nso_build_id == this_build_id)
                        out.push_back(file);
@@ -378,7 +372,6 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
            }
        }
    }
-
    return out;
 }

@@ -566,7 +566,7 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
    return file;
 }

-static std::optional<NcaID> CheckMapForContentRecord(const ankerl::unordered_dense::map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
+static std::optional<NcaID> CheckMapForContentRecord(const boost::unordered::unordered_flat_map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
    auto cmnt_iter = map.find(title_id);
    u8 id_offset = 0;

@@ -12,7 +12,6 @@
 #include <optional>
 #include <string>
 #include <vector>
-#include <ankerl/unordered_dense.h>
 #include <boost/container/flat_map.hpp>
 #include "common/common_types.h"
 #include "core/crypto/key_manager.h"
@@ -209,11 +208,11 @@ private:
    ContentProviderParsingFunction parser;

    // maps tid -> NcaID of meta
-    ankerl::unordered_dense::map<u64, NcaID> meta_id;
+    boost::container::flat_map<u64, NcaID> meta_id;
    // maps tid -> meta
-    ankerl::unordered_dense::map<u64, CNMT> meta;
+    boost::container::flat_map<u64, CNMT> meta;
    // maps tid -> meta for CNMT in yuzu_meta
-    ankerl::unordered_dense::map<u64, CNMT> yuzu_meta;
+    boost::container::flat_map<u64, CNMT> yuzu_meta;
 };

 enum class ContentProviderUnionSlot {
@@ -313,8 +312,8 @@ private:
    void ProcessXCI(const VirtualFile& file);

    std::vector<VirtualDir> load_dirs;
-    ankerl::unordered_dense::map<std::tuple<u64, ContentRecordType, TitleType>, VirtualFile> entries;
-    ankerl::unordered_dense::map<u64, u32> versions;
+    boost::container::flat_map<std::tuple<u64, ContentRecordType, TitleType>, VirtualFile> entries;
+    boost::container::flat_map<u64, u32> versions;
    std::vector<ExternalUpdateEntry> multi_version_entries;
 };

@@ -4,9 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include <algorithm>
-#include <set>
-#include <ankerl/unordered_dense.h>
+#include <boost/container/flat_set.hpp>
 #include <utility>
 #include "core/file_sys/vfs/vfs_layered.h"

@@ -63,7 +61,7 @@ std::string LayeredVfsDirectory::GetFullPath() const {

 std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
    std::vector<VirtualFile> out;
-    ankerl::unordered_dense::set<std::string> out_names;
+    boost::container::flat_set<std::string> out_names;

    for (const auto& layer : dirs) {
        for (auto& file : layer->GetFiles()) {
@@ -79,8 +77,7 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {

 std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
    std::vector<VirtualDir> out;
-    ankerl::unordered_dense::set<std::string> out_names;
-
+    boost::container::flat_set<std::string> out_names;
    for (const auto& layer : dirs) {
        for (const auto& sd : layer->GetSubdirectories()) {
            out_names.emplace(sd->GetName());
@@ -78,7 +78,7 @@ private:
    std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{};
    std::map<KProcessAddress, u64> m_debug_page_refcounts{};
 #ifdef HAS_NCE
-    ankerl::unordered_dense::map<u64, u64> m_post_handlers{};
+    boost::unordered::unordered_flat_map<u64, u64> m_post_handlers{};
 #endif
    std::unique_ptr<Core::ExclusiveMonitor> m_exclusive_monitor;
    Core::Memory::Memory m_memory;
@@ -494,7 +494,7 @@ public:
    static void Switch(KernelCore& kernel, KProcess* cur_process, KProcess* next_process);

 #ifdef HAS_NCE
-    ankerl::unordered_dense::map<u64, u64>& GetPostHandlers() noexcept {
+    boost::unordered::unordered_flat_map<u64, u64>& GetPostHandlers() noexcept {
        return m_post_handlers;
    }
 #endif
@@ -10,7 +10,8 @@
 #include <functional>
 #include <memory>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <utility>

 #include "common/assert.h"
@@ -792,8 +793,8 @@ struct KernelCore::Impl {

    std::optional<KObjectNameGlobalData> object_name_global_data;

-    ankerl::unordered_dense::set<KAutoObject*> registered_objects;
-    ankerl::unordered_dense::set<KAutoObject*> registered_in_use_objects;
+    boost::unordered::unordered_flat_set<KAutoObject*> registered_objects;
+    boost::unordered::unordered_flat_set<KAutoObject*> registered_in_use_objects;

    std::mutex server_lock;
    std::vector<std::unique_ptr<Service::ServerManager>> server_managers;
@@ -11,7 +11,8 @@
 #include <list>
 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 #include "common/polyfill_thread.h"
@@ -17,56 +17,12 @@

 namespace Kernel::Svc {

-constexpr auto MAX_MSG_TIME = std::chrono::milliseconds(250);
-const auto MAX_MSG_SIZE = 0x1000;
-
 /// Used to output a message on a debug hardware unit - does nothing on a retail unit
 Result OutputDebugString(Core::System& system, u64 address, u64 len) {
-    static struct DebugFlusher {
-        std::string msg_buffer;
-        std::mutex msg_mutex;
-        std::condition_variable msg_cv;
-        std::chrono::steady_clock::time_point last_msg_time;
-        std::optional<std::jthread> thread;
-    } flusher_data;
    R_SUCCEED_IF(len == 0);
-    // Only start the thread the very first time this function is called
-    if (!flusher_data.thread) {
-        flusher_data.thread.emplace([](std::stop_token stop_token) {
-            while (!stop_token.stop_requested()) {
-                std::unique_lock lock(flusher_data.msg_mutex);
-                flusher_data.msg_cv.wait(lock, [&stop_token] {
-                    return !flusher_data.msg_buffer.empty() || stop_token.stop_requested();
-                });
-                if (stop_token.stop_requested() && flusher_data.msg_buffer.empty())
-                    break;
-                auto timeout = flusher_data.last_msg_time + MAX_MSG_TIME;
-                bool woke_early = flusher_data.msg_cv.wait_until(lock, timeout, [&stop_token] {
-                    return flusher_data.msg_buffer.size() >= MAX_MSG_SIZE || stop_token.stop_requested();
-                });
-                if (!woke_early || flusher_data.msg_buffer.size() >= MAX_MSG_SIZE || stop_token.stop_requested()) {
-                    if (!flusher_data.msg_buffer.empty()) {
-                        // Remove trailing newline as LOG_INFO adds that anyways
-                        if (flusher_data.msg_buffer.back() == '\n')
-                            flusher_data.msg_buffer.pop_back();
-
-                        LOG_INFO(Debug_Emulated, "\n{}", flusher_data.msg_buffer);
-                        flusher_data.msg_buffer.clear();
-                    }
-                    if (stop_token.stop_requested()) break;
-                }
-            }
-            flusher_data.msg_cv.notify_all();
-        });
-    }
-    {
-        std::lock_guard lock(flusher_data.msg_mutex);
-        const auto old_size = flusher_data.msg_buffer.size();
-        flusher_data.msg_buffer.resize(old_size + len);
-        GetCurrentMemory(system.Kernel()).ReadBlock(address, flusher_data.msg_buffer.data() + old_size, len);
-        flusher_data.last_msg_time = std::chrono::steady_clock::now();
-    }
-    flusher_data.msg_cv.notify_one();
+    std::string msg_buffer(len, 0);
+    GetCurrentMemory(system.Kernel()).ReadBlock(address, msg_buffer.data(), len);
+    LOG_INFO(Debug_Emulated, "{}", msg_buffer);
    R_SUCCEED();
 }

@@ -7,7 +7,8 @@
 #pragma once

 #include <array>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 #include "common/common_funcs.h"
@@ -176,6 +177,6 @@ struct WebCommonReturnValue {
 };
 static_assert(sizeof(WebCommonReturnValue) == 0x1010, "WebCommonReturnValue has incorrect size.");

-using WebArgInputTLVMap = ankerl::unordered_dense::map<WebArgInputTLVType, std::vector<u8>>;
+using WebArgInputTLVMap = boost::unordered::unordered_flat_map<WebArgInputTLVType, std::vector<u8>>;

 } // namespace Service::AM::Frontend
@@ -40,8 +40,8 @@ std::vector<u8> default_logo_small;
 std::vector<u8> default_logo_large;
 bool default_logos_loaded = false;

-ankerl::unordered_dense::map<std::string, std::vector<u8>> news_images_small;
-ankerl::unordered_dense::map<std::string, std::vector<u8>> news_images_large;
+boost::unordered::unordered_flat_map<std::string, std::vector<u8>> news_images_small;
+boost::unordered::unordered_flat_map<std::string, std::vector<u8>> news_images_large;
 std::mutex images_mutex;


@@ -12,7 +12,8 @@
 #include <optional>
 #include <span>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 #include "common/common_types.h"
@@ -93,7 +94,7 @@ private:
    static s64 Now();

    mutable std::mutex mtx;
-    ankerl::unordered_dense::map<std::string, StoredNews> items;
+    boost::unordered::unordered_flat_map<std::string, StoredNews> items;
    size_t open_counter{};
 };

@@ -6,7 +6,8 @@

 #pragma once

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/fs/fs.h"
 #include "core/hle/result.h"
@@ -88,7 +89,7 @@ private:
    AlbumFileDateTime ConvertToAlbumDateTime(u64 posix_time) const;

    bool is_mounted{};
-    ankerl::unordered_dense::map<AlbumFileId, std::filesystem::path> album_files;
+    boost::unordered::unordered_flat_map<AlbumFileId, std::filesystem::path> album_files;

    Core::System& system;
 };
@@ -15,7 +15,8 @@
 #include <random>
 #include <span>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/logging.h"
 #include "common/socket_types.h"
@@ -119,7 +120,7 @@ protected:
    std::array<LanStation, StationCountMax> stations;
    std::array<NodeLatestUpdate, NodeCountMax> node_changes{};
    std::array<u8, NodeCountMax> node_last_states{};
-    ankerl::unordered_dense::map<MacAddress, NetworkInfo, MACAddressHash> scan_results{};
+    boost::unordered::unordered_flat_map<MacAddress, NetworkInfo, MACAddressHash> scan_results{};
    NodeInfo node_info{};
    NetworkInfo network_info{};
    State state{State::None};
@@ -7,7 +7,8 @@
 #include <string>

 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/container_hash/hash.hpp>
 #include "common/logging.h"
 #include "core/core.h"
@@ -331,7 +332,7 @@ private:
    };
    static_assert(sizeof(LogPacketHeader) == 0x18, "LogPacketHeader is an invalid size");

-    ankerl::unordered_dense::map<LogPacketHeaderEntry, std::vector<u8>> entries{};
+    boost::unordered::unordered_flat_map<LogPacketHeaderEntry, std::vector<u8>> entries{};
    LogDestination destination{LogDestination::All};
 };

@@ -23,7 +23,8 @@
 #include <mutex>
 #include <optional>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <common/settings.h>

 #ifdef _WIN32
@@ -9,7 +9,8 @@

 #include <deque>
 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "core/device_memory_manager.h"
 #include "core/hle/service/nvdrv/nvdata.h"
@@ -12,7 +12,8 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <assert.h>

 #include "common/bit_field.h"
@@ -161,7 +162,7 @@ private:
    std::list<std::shared_ptr<Handle>> unmap_queue{};
    std::mutex unmap_queue_lock{}; //!< Protects access to `unmap_queue`

-    ankerl::unordered_dense::map<Handle::Id, std::shared_ptr<Handle>>
+    boost::unordered::unordered_flat_map<Handle::Id, std::shared_ptr<Handle>>
        handles{};           //!< Main owning map of handles
    std::mutex handles_lock; //!< Protects access to `handles`

@@ -13,7 +13,8 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 #include "common/address_space.h"
@@ -113,7 +114,7 @@ private:
    };
    static_assert(sizeof(IoctlRemapEntry) == 20, "IoctlRemapEntry is incorrect size");

-    ankerl::unordered_dense::set<s64_le> map_buffer_offsets{};
+    boost::unordered::unordered_flat_set<s64_le> map_buffer_offsets{};

    struct IoctlMapBufferEx {
        MappingFlags flags{}; // bit0: fixed_offset, bit2: cacheable
@@ -217,7 +217,7 @@ private:
    NvCore::SyncpointManager& syncpoint_manager;
    NvCore::NvMap& nvmap;
    std::shared_ptr<Tegra::Control::ChannelState> channel_state;
-    ankerl::unordered_dense::map<DeviceFD, NvCore::SessionId> sessions;
+    boost::unordered::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
    u32 channel_syncpoint;
    std::mutex channel_mutex;

@@ -7,7 +7,8 @@
 #pragma once

 #include <deque>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 #include "common/common_types.h"
@@ -138,7 +139,7 @@ protected:
    NvCore::NvMap& nvmap;
    NvCore::ChannelType channel_type;
    std::array<u32, MaxSyncPoints> device_syncpoints{};
-    ankerl::unordered_dense::map<DeviceFD, NvCore::SessionId> sessions;
+    boost::unordered::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
 };
 }; // namespace Devices
 } // namespace Service::Nvidia
@@ -7,7 +7,8 @@
 #pragma once

 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -118,7 +119,7 @@ private:

    NvCore::Container& container;
    NvCore::NvMap& file;
-    ankerl::unordered_dense::map<DeviceFD, NvCore::SessionId> sessions;
+    boost::unordered::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
 };

 } // namespace Service::Nvidia::Devices
@@ -12,7 +12,8 @@
 #include <memory>
 #include <span>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/common_types.h"
 #include "core/hle/service/kernel_helpers.h"
@@ -103,7 +104,7 @@ private:
    /// Id to use for the next open file descriptor.
    DeviceFD next_fd = 1;

-    using FilesContainerType = ankerl::unordered_dense::map<DeviceFD, std::shared_ptr<Devices::nvdevice>>;
+    using FilesContainerType = boost::unordered::unordered_flat_map<DeviceFD, std::shared_ptr<Devices::nvdevice>>;
    /// Mapping of file descriptors to the devices they reference.
    FilesContainerType open_files;

@@ -111,7 +112,7 @@ private:

    EventInterface events_interface;

-    ankerl::unordered_dense::map<std::string, std::function<FilesContainerType::iterator(DeviceFD)>> builders;
+    boost::unordered::unordered_flat_map<std::string, std::function<FilesContainerType::iterator(DeviceFD)>> builders;
 };

 void LoopProcess(Core::System& system);
@@ -8,7 +8,8 @@

 #include <memory>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/common_types.h"
 #include "core/hle/service/nvnflinger/binder.h"
@@ -39,8 +40,8 @@ private:

    mutable std::mutex lock;
    s32 last_id = 0;
-    ankerl::unordered_dense::map<s32, std::shared_ptr<android::IBinder>> binders;
-    ankerl::unordered_dense::map<s32, RefCounts> refcounts;
+    boost::unordered::unordered_flat_map<s32, std::shared_ptr<android::IBinder>> binders;
+    boost::unordered::unordered_flat_map<s32, RefCounts> refcounts;
 };

 } // namespace Service::Nvnflinger
@@ -6,7 +6,8 @@

 #pragma once

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/uuid.h"
 #include "core/hle/service/cmif_types.h"
@@ -56,10 +57,10 @@ private:
        }
    };

-    ankerl::unordered_dense::map<AppKey, bool, AppKeyHash> app_auto_transfer_{};
-    ankerl::unordered_dense::map<Common::UUID, bool> global_auto_upload_{};
-    ankerl::unordered_dense::map<Common::UUID, bool> global_auto_download_{};
-    ankerl::unordered_dense::map<AppKey, u8, AppKeyHash> autonomy_task_status_{};
+    boost::unordered::unordered_flat_map<AppKey, bool, AppKeyHash> app_auto_transfer_{};
+    boost::unordered::unordered_flat_map<Common::UUID, bool> global_auto_upload_{};
+    boost::unordered::unordered_flat_map<Common::UUID, bool> global_auto_download_{};
+    boost::unordered::unordered_flat_map<AppKey, u8, AppKeyHash> autonomy_task_status_{};
 };

 } // namespace Service::OLSC
@@ -8,7 +8,8 @@

 #include <cstddef>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include "common/common_types.h"
 #include "core/hle/service/hle_ipc.h"

@@ -99,8 +100,8 @@ private:
    void ReportUnimplementedFunction(HLERequestContext& ctx, const FunctionInfoBase* info);

 protected:
-    ankerl::unordered_dense::map<u32, FunctionInfoBase> handlers;
-    ankerl::unordered_dense::map<u32, FunctionInfoBase> handlers_tipc;
+    boost::unordered::unordered_flat_map<u32, FunctionInfoBase> handlers;
+    boost::unordered::unordered_flat_map<u32, FunctionInfoBase> handlers_tipc;
    /// Used to gain exclusive access to the service members, e.g. from CoreTiming thread.
    std::mutex lock_service;
    /// System context that the service operates under.
@@ -10,7 +10,8 @@
 #include <memory>
 #include <mutex>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <concepts>

 #include "core/hle/kernel/k_port.h"
@@ -100,8 +101,8 @@ private:

    /// Map of registered services, retrieved using GetServicePort.
    mutable std::mutex lock;
-    ankerl::unordered_dense::map<std::string, SessionRequestHandlerFactory> registered_services;
-    ankerl::unordered_dense::map<std::string, Kernel::KClientPort*> service_ports;
+    boost::unordered::unordered_flat_map<std::string, SessionRequestHandlerFactory> registered_services;
+    boost::unordered::unordered_flat_map<std::string, Kernel::KClientPort*> service_ports;

    /// Kernel context
    Kernel::KernelCore& kernel;
@@ -7,7 +7,8 @@
 #pragma once

 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/common_types.h"
 #include "common/polyfill_thread.h"
@@ -49,7 +50,7 @@ private:
 private:
    Core::System& m_system;
    Container& m_container;
-    ankerl::unordered_dense::map<u64, VsyncManager> m_vsync_managers;
+    boost::unordered::unordered_flat_map<u64, VsyncManager> m_vsync_managers;
    std::shared_ptr<Core::Timing::EventType> m_event;
    Common::Event m_signal;
    std::jthread m_thread;
@@ -8,7 +8,7 @@
 #include <mutex>
 #include <sstream>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/container/flat_map.hpp>

 #include <fmt/format.h>
 #include <nlohmann/json.hpp>
@@ -21,12 +21,9 @@
 namespace Core::LaunchTimestampCache {
 namespace {

-using CacheMap = ankerl::unordered_dense::map<u64, s64>;
-using CountMap = ankerl::unordered_dense::map<u64, u64>;
-
 std::mutex g_mutex;
-CacheMap g_cache;
-CountMap g_counts;
+boost::container::flat_map<u64, s64> g_cache;
+boost::container::flat_map<u64, u64> g_counts;
 bool g_loaded = false;

 std::filesystem::path GetCachePath() {
@@ -120,8 +120,6 @@ if (NOT Boost_FOUND)
 endif()

 find_package(fmt 8 CONFIG)
-find_package(unordered_dense REQUIRED)
-
 if ("arm64" IN_LIST ARCHITECTURE OR DYNARMIC_TESTS)
    find_package(oaknut 2.0.1 CONFIG)
 endif()
@@ -8,8 +8,6 @@ if (NOT @BUILD_SHARED_LIBS@)
    find_dependency(Boost 1.57)
    find_dependency(fmt 9)
    find_dependency(mcl 0.1.12 EXACT)
-    find_dependency(unordered_dense)
-
    if ("arm64" IN_LIST ARCHITECTURE)
        find_dependency(oaknut 2.0.1)
    endif()
@@ -386,8 +386,6 @@ set_target_properties(dynarmic PROPERTIES
 )

 target_compile_options(dynarmic PRIVATE ${DYNARMIC_CXX_FLAGS})
-
-target_link_libraries(dynarmic PRIVATE unordered_dense::unordered_dense)
 target_link_libraries(dynarmic PUBLIC fmt::fmt common)

 if (BOOST_NO_HEADERS)
@@ -75,7 +75,7 @@ CodePtr AddressSpace::GetOrEmit(IR::LocationDescriptor descriptor) {
    return block_info.entry_point;
 }

-void AddressSpace::InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& descriptors) {
+void AddressSpace::InvalidateBasicBlocks(const boost::unordered::unordered_flat_set<IR::LocationDescriptor>& descriptors) {
    UnprotectCodeMemory();

    for (const auto& descriptor : descriptors) {
@@ -14,7 +14,8 @@
 #include "common/common_types.h"
 #include <oaknut/code_block.hpp>
 #include <oaknut/oaknut.hpp>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/backend/arm64/emit_arm64.h"
 #include "dynarmic/backend/arm64/fastmem.h"
@@ -41,7 +42,7 @@ public:

    CodePtr GetOrEmit(IR::LocationDescriptor descriptor);

-    void InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& descriptors);
+    void InvalidateBasicBlocks(const boost::unordered::unordered_flat_set<IR::LocationDescriptor>& descriptors);

    void ClearCache();
 protected:
@@ -76,9 +77,9 @@ protected:
    // A IR::LocationDescriptor will have one current CodePtr.
    // However, there can be multiple other CodePtrs which are older, previously invalidated blocks.
    std::map<CodePtr, IR::LocationDescriptor> reverse_block_entries;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, CodePtr> block_entries;
-    ankerl::unordered_dense::map<CodePtr, EmittedBlockInfo> block_infos;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, ankerl::unordered_dense::set<CodePtr>> block_references;
+    boost::unordered::unordered_flat_map<IR::LocationDescriptor, CodePtr> block_entries;
+    boost::unordered::unordered_flat_map<CodePtr, EmittedBlockInfo> block_infos;
+    boost::unordered::unordered_flat_map<IR::LocationDescriptor, boost::unordered::unordered_flat_set<CodePtr>> block_references;

    ExceptionHandler exception_handler;
    FastmemManager fastmem_manager;
@@ -14,7 +14,8 @@
 #include <vector>

 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/backend/arm64/fastmem.h"
 #include "dynarmic/interface/A32/coprocessor.h"
@@ -105,8 +106,8 @@ struct EmittedBlockInfo {
    CodePtr entry_point;
    std::size_t size;
    std::vector<Relocation> relocations;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, std::vector<BlockRelocation>> block_relocations;
-    ankerl::unordered_dense::map<std::ptrdiff_t, FastmemPatchInfo> fastmem_patch_info;
+    boost::unordered::unordered_flat_map<IR::LocationDescriptor, std::vector<BlockRelocation>> block_relocations;
+    boost::unordered::unordered_flat_map<std::ptrdiff_t, FastmemPatchInfo> fastmem_patch_info;
 };

 struct EmitConfig {
@@ -10,7 +10,8 @@

 #include <cstddef>
 #include <tuple>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/mcl/bit.hpp"
 #include "common/common_types.h"
@@ -59,7 +60,7 @@ public:

 private:
    ExceptionHandler& exception_handler;
-    ankerl::unordered_dense::set<DoNotFastmemMarker, DoNotFastmemMarkerHash> do_not_fastmem;
+    boost::unordered::unordered_flat_set<DoNotFastmemMarker, DoNotFastmemMarkerHash> do_not_fastmem;
 };

 }  // namespace Dynarmic::Backend::Arm64
@@ -18,7 +18,8 @@
 #include "common/common_types.h"
 #include "dynarmic/mcl/is_instance_of_template.hpp"
 #include <oaknut/oaknut.hpp>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/backend/arm64/stack_layout.h"
 #include "dynarmic/ir/cond.h"
@@ -336,7 +337,7 @@ private:
    std::array<HostLocInfo, SpillCount> spills;

    mutable std::size_t alloc_candidate_index = 0;
-    ankerl::unordered_dense::set<const IR::Inst*> defined_insts;
+    boost::unordered::unordered_flat_set<const IR::Inst*> defined_insts;
 };

 template<typename T>
@@ -11,13 +11,14 @@
 #include <boost/icl/interval_map.hpp>
 #include <boost/icl/interval_set.hpp>
 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 namespace Dynarmic::Backend {

 template<typename P>
 void BlockRangeInformation<P>::AddRange(boost::icl::discrete_interval<P> range, IR::LocationDescriptor location) {
-    block_ranges.add(std::make_pair(range, ankerl::unordered_dense::set<IR::LocationDescriptor>{location}));
+    block_ranges.add(std::make_pair(range, boost::unordered::unordered_flat_set<IR::LocationDescriptor>{location}));
 }

 template<typename P>
@@ -26,8 +27,8 @@ void BlockRangeInformation<P>::ClearCache() {
 }

 template<typename P>
-ankerl::unordered_dense::set<IR::LocationDescriptor> BlockRangeInformation<P>::InvalidateRanges(const boost::icl::interval_set<P>& ranges) {
-    ankerl::unordered_dense::set<IR::LocationDescriptor> erase_locations;
+boost::unordered::unordered_flat_set<IR::LocationDescriptor> BlockRangeInformation<P>::InvalidateRanges(const boost::icl::interval_set<P>& ranges) {
+    boost::unordered::unordered_flat_set<IR::LocationDescriptor> erase_locations;
    for (auto invalidate_interval : ranges) {
        auto pair = block_ranges.equal_range(invalidate_interval);
        for (auto it = pair.first; it != pair.second; ++it)
@@ -12,7 +12,8 @@

 #include <boost/icl/interval_map.hpp>
 #include <boost/icl/interval_set.hpp>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/ir/location_descriptor.h"

@@ -23,8 +24,8 @@ class BlockRangeInformation {
 public:
    void AddRange(boost::icl::discrete_interval<P> range, IR::LocationDescriptor location);
    void ClearCache();
-    ankerl::unordered_dense::set<IR::LocationDescriptor> InvalidateRanges(const boost::icl::interval_set<P>& ranges);
-    boost::icl::interval_map<P, ankerl::unordered_dense::set<IR::LocationDescriptor>> block_ranges;
+    boost::unordered::unordered_flat_set<IR::LocationDescriptor> InvalidateRanges(const boost::icl::interval_set<P>& ranges);
+    boost::icl::interval_map<P, boost::unordered::unordered_flat_set<IR::LocationDescriptor>> block_ranges;
 };

 }  // namespace Dynarmic::Backend
@@ -17,7 +17,8 @@
 #include <optional>
 #include <shared_mutex>

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <fmt/format.h>
 #include <sys/mman.h>

@@ -55,7 +56,7 @@ class SigHandler {
        });
    }

-    ankerl::unordered_dense::map<u64, CodeBlockInfo> code_block_infos;
+    boost::unordered::unordered_flat_map<u64, CodeBlockInfo> code_block_infos;
    std::shared_mutex code_block_infos_mutex;
    struct sigaction old_sa_segv;
    struct sigaction old_sa_bus;
@@ -3,9 +3,8 @@

 #pragma once

+#include <boost/unordered/unordered_flat_map.hpp>
 #include "dynarmic/backend/loongarch64/lagoon_cpp.h"
-#include <ankerl/unordered_dense.h>
-
 #include "dynarmic/backend/loongarch64/code_block.h"
 #include "dynarmic/backend/loongarch64/emit_loongarch64.h"
 #include "dynarmic/interface/A32/config.h"
@@ -53,8 +52,8 @@ private:
    const A32::UserConfig conf;
    CodeBlock cb;

-    ankerl::unordered_dense::map<u64, CodePtr> block_entries;
-    ankerl::unordered_dense::map<u64, EmittedBlockInfo> block_infos;
+    boost::container::unordered_map<u64, CodePtr> block_entries;
+    boost::container::unordered_map<u64, EmittedBlockInfo> block_infos;

 public:
    struct PreludeInfo {
@@ -9,7 +9,8 @@
 #include <vector>

 #include "dynarmic/backend/loongarch64/lagoon_cpp.h"
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/assert.h"
 #include "common/common_types.h"
@@ -9,7 +9,8 @@
 #pragma once

 #include <biscuit/assembler.hpp>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/backend/riscv64/code_block.h"
 #include "dynarmic/backend/riscv64/emit_riscv64.h"
@@ -74,8 +75,8 @@ private:
    CodeBlock cb;
    biscuit::Assembler as;

-    ankerl::unordered_dense::map<u64, CodePtr> block_entries;
-    ankerl::unordered_dense::map<u64, EmittedBlockInfo> block_infos;
+    boost::unordered::unordered_flat_map<u64, CodePtr> block_entries;
+    boost::unordered::unordered_flat_map<u64, EmittedBlockInfo> block_infos;

    struct PreludeInfo {
        CodePtr end_of_prelude;
@@ -19,7 +19,8 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "dynarmic/mcl/is_instance_of_template.hpp"
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/backend/riscv64/stack_layout.h"
 #include "dynarmic/ir/cond.h"
@@ -13,7 +13,8 @@
 #include <set>
 #include <tuple>

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/backend/block_range_information.h"
 #include "dynarmic/backend/x64/a32_jitstate.h"
@@ -126,11 +127,11 @@ public:
    RegAlloc reg_alloc; //reusable reg alloc
    BlockRangeInformation<u32> block_ranges;
    std::array<FastDispatchEntry, fast_dispatch_table_size> fast_dispatch_table;
-    ankerl::unordered_dense::map<u64, FastmemPatchInfo> fastmem_patch_info;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
-    ankerl::unordered_dense::set<DoNotFastmemMarker> do_not_fastmem;
+    boost::unordered::unordered_flat_map<u64, FastmemPatchInfo> fastmem_patch_info;
+    boost::unordered::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
+    boost::unordered::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
+    boost::unordered::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
+    boost::unordered::unordered_flat_set<DoNotFastmemMarker> do_not_fastmem;
    boost::container::stable_vector<Xbyak::Label> shared_labels;
    void (*memory_read_128)() = nullptr;   // Dummy
    void (*memory_write_128)() = nullptr;  // Dummy
@@ -12,7 +12,8 @@
 #include <map>
 #include <optional>
 #include <tuple>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/container/static_vector.hpp>

 #include "dynarmic/backend/block_range_information.h"
@@ -122,11 +123,11 @@ public:
    RegAlloc reg_alloc; //reusable reg alloc
    BlockRangeInformation<u64> block_ranges;
    std::array<FastDispatchEntry, fast_dispatch_table_size> fast_dispatch_table;
-    ankerl::unordered_dense::map<u64, FastmemPatchInfo> fastmem_patch_info;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
-    ankerl::unordered_dense::set<DoNotFastmemMarker> do_not_fastmem;
+    boost::unordered::unordered_flat_map<u64, FastmemPatchInfo> fastmem_patch_info;
+    boost::unordered::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
+    boost::unordered::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
+    boost::unordered::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
+    boost::unordered::unordered_flat_set<DoNotFastmemMarker> do_not_fastmem;
    boost::container::stable_vector<Xbyak::Label> shared_labels;
    const void* terminal_handler_pop_rsb_hint = nullptr;
    const void* terminal_handler_fast_dispatch_hint = nullptr;
@@ -14,7 +14,8 @@
 #include <utility>

 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include "dynarmic/backend/x64/xbyak.h"

 namespace Dynarmic::Backend::X64 {
@@ -43,7 +44,7 @@ private:
        }
    };

-    ankerl::unordered_dense::map<ConstantT, void*, ConstantHash> constant_info;
+    boost::unordered::unordered_flat_map<ConstantT, void*, ConstantHash> constant_info;
    std::span<ConstantT> pool;
    std::size_t insertion_point;
 };
@@ -14,7 +14,8 @@
 #include <boost/variant/detail/apply_visitor_binary.hpp>
 #include "dynarmic/mcl/bit.hpp"
 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "dynarmic/backend/x64/block_of_code.h"
 #include "dynarmic/backend/x64/nzcv_util.h"
@@ -396,7 +397,7 @@ void EmitX64::ClearCache() {
    PerfMapClear();
 }

-void EmitX64::InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& locations) {
+void EmitX64::InvalidateBasicBlocks(const boost::unordered::unordered_flat_set<IR::LocationDescriptor>& locations) {
    code.EnableWriting();
    for (const auto& descriptor : locations) {
        if (auto const it = block_descriptors.find(descriptor); it != block_descriptors.end()) {
@@ -16,7 +16,8 @@
 #include <type_traits>
 #include <vector>

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/container/stable_vector.hpp>
 #include <boost/container/small_vector.hpp>

@@ -88,7 +89,7 @@ public:
    virtual void ClearCache();

    /// Invalidates a selection of basic blocks.
-    void InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& locations);
+    void InvalidateBasicBlocks(const boost::unordered::unordered_flat_set<IR::LocationDescriptor>& locations);

 //protected:
    // Microinstruction emitters
@@ -131,8 +132,8 @@ public:
    // State
    BlockOfCode& code;
    ExceptionHandler exception_handler;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, BlockDescriptor> block_descriptors;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, PatchInformation> patch_information;
+    boost::unordered::unordered_flat_map<IR::LocationDescriptor, BlockDescriptor> block_descriptors;
+    boost::unordered::unordered_flat_map<IR::LocationDescriptor, PatchInformation> patch_information;

    // We need materialized protected members
    friend class A64EmitX64;
@@ -4,10 +4,11 @@
 #pragma once

 // You must ensure this matches with src/common/x64/xbyak.h on root dir
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/unordered_map.hpp>
-#define XBYAK_STD_UNORDERED_SET ankerl::unordered_dense::set
-#define XBYAK_STD_UNORDERED_MAP ankerl::unordered_dense::map
+#define XBYAK_STD_UNORDERED_SET boost::unordered::unordered_flat_set
+#define XBYAK_STD_UNORDERED_MAP boost::unordered::unordered_flat_map
 #define XBYAK_STD_UNORDERED_MULTIMAP boost::unordered_multimap
 #include <xbyak/xbyak.h>
 #include <xbyak/xbyak_util.h>
@@ -11,7 +11,8 @@
 #include <map>
 #include <bit>

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include "boost/container/small_vector.hpp"
 #include "dynarmic/frontend/A32/a32_ir_emitter.h"
 #include "dynarmic/frontend/A32/a32_location_descriptor.h"
@@ -1433,7 +1434,7 @@ static void VerificationPass(const IR::Block& block) {
            ASSERT(IR::AreTypesCompatible(t1, t2));
        }
    }
-    ankerl::unordered_dense::map<IR::Inst*, size_t> actual_uses;
+    boost::unordered::unordered_flat_map<IR::Inst*, size_t> actual_uses;
    for (auto const& inst : block.instructions) {
        for (size_t i = 0; i < inst.NumArgs(); i++)
            if (IR::Value const arg = inst.GetArg(i); !arg.IsImmediate())
@@ -8,7 +8,8 @@

 #include <array>
 #include <exception>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include <catch2/catch_test_macros.hpp>
 #include "common/common_types.h"
@@ -23,7 +24,7 @@ namespace {
 class MyEnvironment final : public A64::UserCallbacks {
 public:
    u64 ticks_left = 0;
-    ankerl::unordered_dense::map<u64, u8> memory{};
+    boost::unordered::unordered_flat_map<u64, u8> memory{};

    u8 MemoryRead8(u64 vaddr) override {
        return memory[vaddr];
@@ -8,7 +8,8 @@

 #pragma once

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "dynarmic/interface/A64/a64.h"
@@ -17,7 +18,7 @@ using Vector = Dynarmic::A64::Vector;

 class A64TestEnv : public Dynarmic::A64::UserCallbacks {
 public:
-    ankerl::unordered_dense::map<u64, u8> modified_memory;
+    boost::unordered::unordered_flat_map<u64, u8> modified_memory;
    std::vector<u32> code_mem;
    u64 ticks_left = 0;
    u64 code_mem_start_address = 0;
@@ -24,7 +24,7 @@ add_executable(dynarmic_tests
    A64/real_world.cpp
    A64/testenv.h
 )
-target_link_libraries(dynarmic_tests PRIVATE merry::oaknut unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_tests PRIVATE merry::oaknut)

 if (DYNARMIC_TESTS_USE_UNICORN)
    target_link_libraries(dynarmic_tests PRIVATE Unicorn::Unicorn)
@@ -72,7 +72,7 @@ add_executable(dynarmic_print_info
    print_info.cpp
 )
 create_target_directory_groups(dynarmic_print_info)
-target_link_libraries(dynarmic_print_info PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_print_info PRIVATE dynarmic fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_print_info PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -93,7 +93,7 @@ add_executable(dynarmic_test_generator

 create_target_directory_groups(dynarmic_test_generator)

-target_link_libraries(dynarmic_test_generator PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_test_generator PRIVATE dynarmic fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_test_generator PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -110,7 +110,7 @@ add_executable(dynarmic_test_reader
    test_reader.cpp
 )
 create_target_directory_groups(dynarmic_test_reader)
-target_link_libraries(dynarmic_test_reader PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_test_reader PRIVATE dynarmic fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_test_reader PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -123,7 +123,7 @@ target_compile_definitions(dynarmic_test_reader PRIVATE FMT_USE_USER_DEFINED_LIT
 #
 create_target_directory_groups(dynarmic_tests)

-target_link_libraries(dynarmic_tests PRIVATE dynarmic Catch2::Catch2WithMain fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_tests PRIVATE dynarmic Catch2::Catch2WithMain fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_tests PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -11,7 +11,8 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -185,7 +186,7 @@ private:

    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
-    ankerl::unordered_dense::map<int, ConsoleUpdateCallback> callback_list;
+    boost::unordered::unordered_flat_map<int, ConsoleUpdateCallback> callback_list;
    int last_callback_key = 0;

    // Stores the current status of all console input
@@ -14,7 +14,8 @@
 #include <vector>
 #include <atomic>

-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/common_types.h"
 #include "common/input.h"
@@ -636,7 +637,7 @@ private:
    ControllerMotionDevices virtual_motion_devices;

    mutable std::mutex callback_mutex;
-    ankerl::unordered_dense::map<int, ControllerUpdateCallback> callback_list;
+    boost::unordered::unordered_flat_map<int, ControllerUpdateCallback> callback_list;
    int last_callback_key = 0;

    // Stores the current status of all controller input
@@ -10,7 +10,8 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 #include "common/common_types.h"
@@ -205,7 +206,7 @@ private:

    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
-    ankerl::unordered_dense::map<int, InterfaceUpdateCallback> callback_list;
+    boost::unordered::unordered_flat_map<int, InterfaceUpdateCallback> callback_list;
    int last_callback_key = 0;

    // Stores the current status of all external device input
@@ -90,7 +90,7 @@ public:
    Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;

 private:
-    ankerl::unordered_dense::map<PadIdentifier, jobject> input_devices;
+    boost::unordered::unordered_flat_map<PadIdentifier, jobject> input_devices;

    /// Returns the correct identifier corresponding to the player index
    PadIdentifier GetIdentifier(const std::string& guid, size_t port) const;
@@ -732,7 +732,7 @@ SDLDriver::~SDLDriver() {

 std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
    std::vector<Common::ParamPackage> devices;
-    ankerl::unordered_dense::map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
+    boost::unordered::unordered_flat_map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
    for (const auto& [key, value] : joystick_map) {
        for (const auto& joystick : value) {
            if (!joystick->GetSDLJoystick()) {
@@ -9,7 +9,8 @@
 #include <atomic>
 #include <mutex>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include <SDL3/SDL.h>

@@ -117,7 +118,7 @@ private:
    Common::SPSCQueue<VibrationRequest> vibration_queue;

    /// Map of GUID of a list of corresponding virtual Joysticks
-    ankerl::unordered_dense::map<Common::UUID, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
+    boost::unordered::unordered_flat_map<Common::UUID, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
    std::mutex joystick_map_mutex;

    bool start_thread = false;
@@ -8,7 +8,7 @@

 #include <functional>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include <boost/container/flat_map.hpp>

 #include "common/common_types.h"
 #include "common/input.h"
@@ -270,10 +270,10 @@ protected:

 private:
    struct ControllerData {
-        ankerl::unordered_dense::map<int, bool> buttons;
-        ankerl::unordered_dense::map<int, u8> hat_buttons;
-        ankerl::unordered_dense::map<int, float> axes;
-        ankerl::unordered_dense::map<int, BasicMotion> motions;
+        boost::container::flat_map<int, bool> buttons;
+        boost::container::flat_map<int, u8> hat_buttons;
+        boost::container::flat_map<int, float> axes;
+        boost::container::flat_map<int, BasicMotion> motions;
        Common::Input::BatteryLevel battery{};
        Common::Input::BodyColorStatus color{};
        Common::Input::CameraStatus camera{};
@@ -301,8 +301,8 @@ private:
    bool configuring{false};
    const std::string input_engine;
    int last_callback_key = 0;
-    ankerl::unordered_dense::map<PadIdentifier, ControllerData> controller_list;
-    ankerl::unordered_dense::map<int, InputIdentifier> callback_list;
+    boost::unordered::unordered_flat_map<PadIdentifier, ControllerData> controller_list;
+    boost::unordered::unordered_flat_map<int, InputIdentifier> callback_list;
    MappingCallback mapping_callback;
 };

@@ -8,7 +8,8 @@

 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 namespace Common {
@@ -56,9 +57,9 @@ enum class InputType { None, Button, Stick, Motion, Touch };
 * Given a ParamPackage for a Device returned from `GetInputDevices`, attempt to get the default
 * mapping for the device.
 */
-using AnalogMapping = ankerl::unordered_dense::map<Settings::NativeAnalog::Values, Common::ParamPackage>;
-using ButtonMapping = ankerl::unordered_dense::map<Settings::NativeButton::Values, Common::ParamPackage>;
-using MotionMapping = ankerl::unordered_dense::map<Settings::NativeMotion::Values, Common::ParamPackage>;
+using AnalogMapping = boost::unordered::unordered_flat_map<Settings::NativeAnalog::Values, Common::ParamPackage>;
+using ButtonMapping = boost::unordered::unordered_flat_map<Settings::NativeButton::Values, Common::ParamPackage>;
+using MotionMapping = boost::unordered::unordered_flat_map<Settings::NativeMotion::Values, Common::ParamPackage>;

 class InputSubsystem {
 public:
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later

 #include <filesystem>
+#include <system_error>
 #include <JlCompress.h>
 #include "frontend_common/mod_manager.h"
 #include "mod.h"
@@ -124,8 +125,8 @@ const QString ExtractMod(const QString& path) {
    fs::remove_all(tmp, ec);
    if (!fs::create_directories(tmp, ec)) {
        QtCommon::Frontend::Critical(tr("Mod Extract Failed"),
-                                     tr("Failed to create temporary directory %1")
-                                         .arg(QString::fromStdString(tmp.string())));
+                                    tr("Failed to create temporary directory %1")
+                                        .arg(QString::fromStdString(tmp.string())));
        return QString();
    }

@@ -9,7 +9,8 @@
 #include <array>

 #include <sirit/sirit.h>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "shader_recompiler/backend/bindings.h"
 #include "shader_recompiler/frontend/ir/program.h"
@@ -370,7 +371,7 @@ public:
    Id load_const_func_u32x4{};

    // Sirit::Id doesn't play nice with *::set<>
-    ankerl::unordered_dense::set<u32> non_uniform_ids;
+    boost::unordered::unordered_flat_set<u32> non_uniform_ids;

    bool uses_nonuniform_sampled_image{};
    bool uses_nonuniform_storage_image{};
@@ -7,7 +7,8 @@
 #pragma once

 #include <array>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>

 #include "common/common_types.h"
 #include "shader_recompiler/program_header.h"
@@ -126,9 +127,9 @@ protected:
    u32 start_address{};
    bool is_proprietary_driver{};
 public:
-    ankerl::unordered_dense::map<CbufWordKey, u32, CbufWordKeyHash> cbuf_word_cache;
-    ankerl::unordered_dense::map<HandleKey,  u32, HandleKeyHash> handle_cache;
-    ankerl::unordered_dense::map<const IR::Inst*, ConstBufferAddr> track_cache;
+    boost::unordered::unordered_flat_map<CbufWordKey, u32, CbufWordKeyHash> cbuf_word_cache;
+    boost::unordered::unordered_flat_map<HandleKey,  u32, HandleKeyHash> handle_cache;
+    boost::unordered::unordered_flat_map<const IR::Inst*, ConstBufferAddr> track_cache;
 };

 } // namespace Shader
@@ -7,7 +7,8 @@
 #include <algorithm>
 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <utility>
 #include <vector>

@@ -390,7 +391,7 @@ private:
                   std::optional<Node> return_label) {
        Statement* const false_stmt{pool.Create(Identity{}, IR::Condition{false}, &root_stmt)};
        Tree& root{root_stmt.children};
-        ankerl::unordered_dense::map<Flow::Block*, Node> local_labels;
+        boost::unordered::unordered_flat_map<Flow::Block*, Node> local_labels;
        local_labels.reserve(function.blocks.size());

        for (Flow::Block& block : function.blocks) {
@@ -19,7 +19,8 @@
 #include <deque>
 #include <map>
 #include <span>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <variant>
 #include <vector>

@@ -7,7 +7,8 @@
 #include <algorithm>
 #include <bit>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <tuple>
 #include <limits>
 #include <boost/container/small_vector.hpp>
@@ -11,7 +11,8 @@
 #include <mutex>
 #include <stdexcept>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_flat_set.hpp>
 #include <vector>

 #include <catch2/catch_test_macros.hpp>
@@ -39,7 +40,7 @@ public:

 private:
    mutable std::mutex mutex;
-    ankerl::unordered_dense::map<std::thread::id, u32> ids;
+    boost::unordered::unordered_flat_map<std::thread::id, u32> ids;
 };

 class TestControl1 {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
lizzie	e114e9e083	me when sed goes wrong	2026-08-30 08:27:22 +00:00
lizzie	9d5861e830	[*] nuke unordered-dense, use boost::container::unordered_flat_{map,set} Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-08-30 08:15:47 +00:00
lizzie	e5b656e372	[common/logging] Fix long logs, remove clutter on Android logcat (#4310 ) Signed-off-by: lizzie <lizzie@eden-emu.dev> - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- logs normally are like this: ``` 08-27 02:58:48.188 12511 4743 W YuzuNative: [18534.062505] Shader <Warning> shader_recompiler/frontend/maxwell/translate/impl/move_special_register.cpp:141:Read: (STUBBED) SR_WSCALEFACTOR_XY 08-27 02:58:48.188 12511 4743 W YuzuNative: [18534.062513] Shader <Warning> shader_recompiler/frontend/maxwell/translate/impl/move_special_register.cpp:144:Read: (STUBBED) SR_WSCALEFACTOR_Z 08-27 02:58:48.188 12511 4743 W YuzuNative: [18534.062520] Shader <Warning> shader_recompiler/frontend/maxwell/translate/impl/vote.cpp:50:VOTE_vtg: (STUBBED) called 08-27 02:58:48.188 12511 4743 W YuzuNative: [18534.062523] Shader <Warning> shader_recompiler/frontend/ir/ir_emitter.cpp:267:GetFlowTest: (STUBBED) FCSM_TR ``` bunch of redundant info imo instead they should just be ``` 08-27 02:58:48.188 12511 4743 W YuzuNative: Shader shader_recompiler/frontend/maxwell/translate/impl/move_special_register.cpp:141:Read: (STUBBED) SR_WSCALEFACTOR_XY 08-27 02:58:48.188 12511 4743 W YuzuNative: Shader shader_recompiler/frontend/maxwell/translate/impl/move_special_register.cpp:144:Read: (STUBBED) SR_WSCALEFACTOR_Z 08-27 02:58:48.188 12511 4743 W YuzuNative: Shader shader_recompiler/frontend/maxwell/translate/impl/vote.cpp:50:VOTE_vtg: (STUBBED) called 08-27 02:58:48.188 12511 4743 W YuzuNative: Shader shader_recompiler/frontend/ir/ir_emitter.cpp:267:GetFlowTest: (STUBBED) FCSM_TR ``` Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4310 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-08-30 08:24:00 +02:00
lizzie	297e797a32	[hle/kernel] remove flusher thread from OutputDebugString (#4291 ) Signed-off-by: lizzie <lizzie@eden-emu.dev> - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- Unneeded abstraction? either way it seems this thread is not required anyone thinking otherwise feel free to lmk directly contradicts with #4290 and #3744 Remember that messages will be displayed out of order this can make actual debugging much harder I'm afraid Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4291 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-08-30 08:18:50 +02:00
xbzk	48a95da874	[debug] debug knobs adjustments (#4317 ) - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- minor changes to debug knobs: -changed its category to System so it becomes per-game-able (believe me, it's useful) -fixed kotlin field type to UShort -changed get to Get for proper standard -added spacings and more info to docs Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4317 Reviewed-by: Lizzie and Samuel <lizzie@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-08-30 08:17:54 +02:00
rayanmargham	2fd1dc0ff9	[qt] fix closing software dialog color (#4305 ) Signed-off-by: rayanmargham <rayanmargham4@gmail.com> - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- This change fixes the closing software dialogue box having really grayish to white text on a white background making it impossible to read. This fixes default-dark giving it this look with the attached screenshot![image](/attachments/ad7dd13c-3808-4a0e-b29b-1a001a1106e0) Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4305 Reviewed-by: Lizzie and Samuel <lizzie@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev>	2026-08-30 08:16:32 +02:00
Lizzie and Samuel	45b6ecff05	[vulkan, vk_pipeline_cache] PSO Optimizations (#4294 ) PR/Commit Owner: CamilleLaVey This PR prevents the recompilation of shaders when a new session has been started, based on data found on the recompiler, each new session does still recompile already cached shader cache, reducing the reaction and speed of games by at certain level, this prevent the warm-up with post sessions, only needed the initial warm-up and works globally for all games. Co-authored-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4294 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-08-30 08:15:29 +02:00
lizzie	672bcbae01	[file_sys] robust-er IPSwitch compiler (#3911 ) this PR reworks IPS parser to be less stupid what do i mean by this? well generally give it a bit of love so it doesn't do a lot of unsound allocations also simplify the logic greatly (and use memcmp() string idiom instead of trusting the compiler so blindly...) no this doesn't mean to uber optimize IPS to handle 999 gb/s it's more so it doesn't outright crash with edge cases as the previous codebase was quite spaghetty also the major overhead is obviously the vector shenanigans and the I/O -- but thats out of scope Test that IPSwitch mods still properly work WITH ANY GAME IF THERE IS ANY REGRESSION IN SOME GAME/MOD THEN TELL ME Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3911 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-08-30 08:10:51 +02:00