me when sed goes wrong

src/android/app/src/main/jni/game_metadata.cpp

@@ -20,7 +20,7 @@ struct RomMetadata {
     std::vector<u8> icon;
     bool isHomebrew;
 };
-static boost::container::unordered_flat_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();

src/android/app/src/main/jni/native_input.cpp

@@ -21,7 +21,7 @@
 #include "input_common/drivers/virtual_gamepad.h"
 #include "native.h"
 
-boost::container::unordered_flat_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 =

src/common/fs/path_util.cpp

@@ -197,8 +197,8 @@ private:
         SetLegacyPathImpl(legacy_path, new_path);
     }
 
-    boost::container::unordered_flat_map<EdenPath, fs::path> eden_paths;
-    boost::container::unordered_flat_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) {

src/common/host_memory.cpp

@@ -392,7 +392,7 @@ private:
 
     std::mutex placeholder_mutex;                                 ///< Mutex for placeholders
     boost::icl::separate_interval_set<size_t> placeholders;       ///< Mapped placeholders
-    boost::container::unordered_flat_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__)

src/common/input.h

@@ -413,7 +413,7 @@ public:
 namespace Impl {
 
 template <typename InputDeviceType>
-using FactoryListType = boost::container::unordered_flat_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 {

src/common/param_package.h

@@ -16,7 +16,7 @@ namespace Common {
 /// A string-based key-value container supporting serializing to and deserializing from a string
 class ParamPackage {
 public:
-    using DataType = boost::container::unordered_flat_map<std::string, std::string>;
+    using DataType = boost::unordered::unordered_flat_map<std::string, std::string>;
 
     ParamPackage() = default;
     explicit ParamPackage(const std::string& serialized);

src/common/x64/xbyak.h

@@ -25,8 +25,8 @@
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/unordered_map.hpp>
-#define XBYAK_STD_UNORDERED_SET boost::container::unordered_flat_set
-#define XBYAK_STD_UNORDERED_MAP boost::container::unordered_flat_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>

src/core/file_sys/ips_layer.cpp

@@ -105,7 +105,7 @@ struct IPSwitchRecord {
     size_t count;
 };
 struct IPSwitchCompiler::IPSwitchPatch {
-    boost::container::unordered_flat_map<u32, IPSwitchRecord> records;
+    boost::unordered::unordered_flat_map<u32, IPSwitchRecord> records;
     bool enabled;
 };
 

src/core/file_sys/registered_cache.cpp

@@ -566,7 +566,7 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
     return file;
 }
 
-static std::optional<NcaID> CheckMapForContentRecord(const boost::container::unordered_flat_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;
 

src/core/hle/kernel/k_process.h

@@ -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
-    boost::container::unordered_flat_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
-    boost::container::unordered_flat_map<u64, u64>& GetPostHandlers() noexcept {
+    boost::unordered::unordered_flat_map<u64, u64>& GetPostHandlers() noexcept {
         return m_post_handlers;
     }
 #endif

src/core/hle/kernel/kernel.cpp

@@ -793,8 +793,8 @@ struct KernelCore::Impl {
 
     std::optional<KObjectNameGlobalData> object_name_global_data;
 
-    boost::container::unordered_flat_set<KAutoObject*> registered_objects;
-    boost::container::unordered_flat_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;

src/core/hle/service/am/frontend/applet_web_browser_types.h

@@ -177,6 +177,6 @@ struct WebCommonReturnValue {
 };
 static_assert(sizeof(WebCommonReturnValue) == 0x1010, "WebCommonReturnValue has incorrect size.");
 
-using WebArgInputTLVMap = boost::container::unordered_flat_map<WebArgInputTLVType, std::vector<u8>>;
+using WebArgInputTLVMap = boost::unordered::unordered_flat_map<WebArgInputTLVType, std::vector<u8>>;
 
 } // namespace Service::AM::Frontend

src/core/hle/service/bcat/news/builtin_news.cpp

@@ -40,8 +40,8 @@ std::vector<u8> default_logo_small;
 std::vector<u8> default_logo_large;
 bool default_logos_loaded = false;
 
-boost::container::unordered_flat_map<std::string, std::vector<u8>> news_images_small;
-boost::container::unordered_flat_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;
 
 

src/core/hle/service/bcat/news/news_storage.h

@@ -94,7 +94,7 @@ private:
     static s64 Now();
 
     mutable std::mutex mtx;
-    boost::container::unordered_flat_map<std::string, StoredNews> items;
+    boost::unordered::unordered_flat_map<std::string, StoredNews> items;
     size_t open_counter{};
 };
 

src/core/hle/service/caps/caps_manager.h

@@ -89,7 +89,7 @@ private:
     AlbumFileDateTime ConvertToAlbumDateTime(u64 posix_time) const;
 
     bool is_mounted{};
-    boost::container::unordered_flat_map<AlbumFileId, std::filesystem::path> album_files;
+    boost::unordered::unordered_flat_map<AlbumFileId, std::filesystem::path> album_files;
 
     Core::System& system;
 };

src/core/hle/service/ldn/lan_discovery.h

@@ -120,7 +120,7 @@ protected:
     std::array<LanStation, StationCountMax> stations;
     std::array<NodeLatestUpdate, NodeCountMax> node_changes{};
     std::array<u8, NodeCountMax> node_last_states{};
-    boost::container::unordered_flat_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};

src/core/hle/service/lm/lm.cpp

@@ -332,7 +332,7 @@ private:
     };
     static_assert(sizeof(LogPacketHeader) == 0x18, "LogPacketHeader is an invalid size");
 
-    boost::container::unordered_flat_map<LogPacketHeaderEntry, std::vector<u8>> entries{};
+    boost::unordered::unordered_flat_map<LogPacketHeaderEntry, std::vector<u8>> entries{};
     LogDestination destination{LogDestination::All};
 };
 

src/core/hle/service/nvdrv/core/nvmap.h

@@ -162,7 +162,7 @@ private:
     std::list<std::shared_ptr<Handle>> unmap_queue{};
     std::mutex unmap_queue_lock{}; //!< Protects access to `unmap_queue`
 
-    boost::container::unordered_flat_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`
 

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h

@@ -114,7 +114,7 @@ private:
     };
     static_assert(sizeof(IoctlRemapEntry) == 20, "IoctlRemapEntry is incorrect size");
 
-    boost::container::unordered_flat_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

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -217,7 +217,7 @@ private:
     NvCore::SyncpointManager& syncpoint_manager;
     NvCore::NvMap& nvmap;
     std::shared_ptr<Tegra::Control::ChannelState> channel_state;
-    boost::container::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
+    boost::unordered::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
     u32 channel_syncpoint;
     std::mutex channel_mutex;
 

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h

@@ -139,7 +139,7 @@ protected:
     NvCore::NvMap& nvmap;
     NvCore::ChannelType channel_type;
     std::array<u32, MaxSyncPoints> device_syncpoints{};
-    boost::container::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
+    boost::unordered::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
 };
 }; // namespace Devices
 } // namespace Service::Nvidia

src/core/hle/service/nvdrv/devices/nvmap.h

@@ -119,7 +119,7 @@ private:
 
     NvCore::Container& container;
     NvCore::NvMap& file;
-    boost::container::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
+    boost::unordered::unordered_flat_map<DeviceFD, NvCore::SessionId> sessions;
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/nvdrv.h

@@ -104,7 +104,7 @@ private:
     /// Id to use for the next open file descriptor.
     DeviceFD next_fd = 1;
 
-    using FilesContainerType = boost::container::unordered_flat_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;
 
@@ -112,7 +112,7 @@ private:
 
     EventInterface events_interface;
 
-    boost::container::unordered_flat_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);

src/core/hle/service/nvnflinger/hos_binder_driver_server.h

@@ -40,8 +40,8 @@ private:
 
     mutable std::mutex lock;
     s32 last_id = 0;
-    boost::container::unordered_flat_map<s32, std::shared_ptr<android::IBinder>> binders;
-    boost::container::unordered_flat_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

src/core/hle/service/olsc/daemon_controller.h

@@ -57,10 +57,10 @@ private:
         }
     };
 
-    boost::container::unordered_flat_map<AppKey, bool, AppKeyHash> app_auto_transfer_{};
-    boost::container::unordered_flat_map<Common::UUID, bool> global_auto_upload_{};
-    boost::container::unordered_flat_map<Common::UUID, bool> global_auto_download_{};
-    boost::container::unordered_flat_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

src/core/hle/service/service.h

@@ -100,8 +100,8 @@ private:
     void ReportUnimplementedFunction(HLERequestContext& ctx, const FunctionInfoBase* info);
 
 protected:
-    boost::container::unordered_flat_map<u32, FunctionInfoBase> handlers;
-    boost::container::unordered_flat_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.

src/core/hle/service/sm/sm.h

@@ -101,8 +101,8 @@ private:
 
     /// Map of registered services, retrieved using GetServicePort.
     mutable std::mutex lock;
-    boost::container::unordered_flat_map<std::string, SessionRequestHandlerFactory> registered_services;
-    boost::container::unordered_flat_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;

src/core/hle/service/vi/conductor.h

@@ -50,7 +50,7 @@ private:
 private:
     Core::System& m_system;
     Container& m_container;
-    boost::container::unordered_flat_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;

src/dynarmic/src/dynarmic/backend/arm64/address_space.cpp

@@ -75,7 +75,7 @@ CodePtr AddressSpace::GetOrEmit(IR::LocationDescriptor descriptor) {
     return block_info.entry_point;
 }
 
-void AddressSpace::InvalidateBasicBlocks(const boost::container::unordered_flat_set<IR::LocationDescriptor>& descriptors) {
+void AddressSpace::InvalidateBasicBlocks(const boost::unordered::unordered_flat_set<IR::LocationDescriptor>& descriptors) {
     UnprotectCodeMemory();
 
     for (const auto& descriptor : descriptors) {

src/dynarmic/src/dynarmic/backend/arm64/address_space.h

@@ -42,7 +42,7 @@ public:
 
     CodePtr GetOrEmit(IR::LocationDescriptor descriptor);
 
-    void InvalidateBasicBlocks(const boost::container::unordered_flat_set<IR::LocationDescriptor>& descriptors);
+    void InvalidateBasicBlocks(const boost::unordered::unordered_flat_set<IR::LocationDescriptor>& descriptors);
 
     void ClearCache();
 protected:
@@ -77,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;
-    boost::container::unordered_flat_map<IR::LocationDescriptor, CodePtr> block_entries;
-    boost::container::unordered_flat_map<CodePtr, EmittedBlockInfo> block_infos;
-    boost::container::unordered_flat_map<IR::LocationDescriptor, boost::container::unordered_flat_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;

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64.h

@@ -106,8 +106,8 @@ struct EmittedBlockInfo {
     CodePtr entry_point;
     std::size_t size;
     std::vector<Relocation> relocations;
-    boost::container::unordered_flat_map<IR::LocationDescriptor, std::vector<BlockRelocation>> block_relocations;
-    boost::container::unordered_flat_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 {

src/dynarmic/src/dynarmic/backend/arm64/fastmem.h

@@ -60,7 +60,7 @@ public:
 
 private:
     ExceptionHandler& exception_handler;
-    boost::container::unordered_flat_set<DoNotFastmemMarker, DoNotFastmemMarkerHash> do_not_fastmem;
+    boost::unordered::unordered_flat_set<DoNotFastmemMarker, DoNotFastmemMarkerHash> do_not_fastmem;
 };
 
 }  // namespace Dynarmic::Backend::Arm64

src/dynarmic/src/dynarmic/backend/arm64/reg_alloc.h

@@ -337,7 +337,7 @@ private:
     std::array<HostLocInfo, SpillCount> spills;
 
     mutable std::size_t alloc_candidate_index = 0;
-    boost::container::unordered_flat_set<const IR::Inst*> defined_insts;
+    boost::unordered::unordered_flat_set<const IR::Inst*> defined_insts;
 };
 
 template<typename T>

src/dynarmic/src/dynarmic/backend/block_range_information.cpp

@@ -18,7 +18,7 @@ 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, boost::container::unordered_flat_set<IR::LocationDescriptor>{location}));
+    block_ranges.add(std::make_pair(range, boost::unordered::unordered_flat_set<IR::LocationDescriptor>{location}));
 }
 
 template<typename P>
@@ -27,8 +27,8 @@ void BlockRangeInformation<P>::ClearCache() {
 }
 
 template<typename P>
-boost::container::unordered_flat_set<IR::LocationDescriptor> BlockRangeInformation<P>::InvalidateRanges(const boost::icl::interval_set<P>& ranges) {
-    boost::container::unordered_flat_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)

src/dynarmic/src/dynarmic/backend/block_range_information.h

@@ -24,8 +24,8 @@ class BlockRangeInformation {
 public:
     void AddRange(boost::icl::discrete_interval<P> range, IR::LocationDescriptor location);
     void ClearCache();
-    boost::container::unordered_flat_set<IR::LocationDescriptor> InvalidateRanges(const boost::icl::interval_set<P>& ranges);
-    boost::icl::interval_map<P, boost::container::unordered_flat_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

src/dynarmic/src/dynarmic/backend/exception_handler_posix.cpp

@@ -56,7 +56,7 @@ class SigHandler {
         });
     }
 
-    boost::container::unordered_flat_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;

src/dynarmic/src/dynarmic/backend/riscv64/a32_address_space.h

@@ -75,8 +75,8 @@ private:
     CodeBlock cb;
     biscuit::Assembler as;
 
-    boost::container::unordered_flat_map<u64, CodePtr> block_entries;
-    boost::container::unordered_flat_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;

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64.h

@@ -127,11 +127,11 @@ public:
     RegAlloc reg_alloc; //reusable reg alloc
     BlockRangeInformation<u32> block_ranges;
     std::array<FastDispatchEntry, fast_dispatch_table_size> fast_dispatch_table;
-    boost::container::unordered_flat_map<u64, FastmemPatchInfo> fastmem_patch_info;
-    boost::container::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
-    boost::container::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
-    boost::container::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
-    boost::container::unordered_flat_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

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64.h

@@ -123,11 +123,11 @@ public:
     RegAlloc reg_alloc; //reusable reg alloc
     BlockRangeInformation<u64> block_ranges;
     std::array<FastDispatchEntry, fast_dispatch_table_size> fast_dispatch_table;
-    boost::container::unordered_flat_map<u64, FastmemPatchInfo> fastmem_patch_info;
-    boost::container::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
-    boost::container::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
-    boost::container::unordered_flat_map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
-    boost::container::unordered_flat_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;

src/dynarmic/src/dynarmic/backend/x64/constant_pool.h

@@ -44,7 +44,7 @@ private:
         }
     };
 
-    boost::container::unordered_flat_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;
 };

src/dynarmic/src/dynarmic/backend/x64/emit_x64.cpp

@@ -397,7 +397,7 @@ void EmitX64::ClearCache() {
     PerfMapClear();
 }
 
-void EmitX64::InvalidateBasicBlocks(const boost::container::unordered_flat_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()) {

src/dynarmic/src/dynarmic/backend/x64/emit_x64.h

@@ -89,7 +89,7 @@ public:
     virtual void ClearCache();
 
     /// Invalidates a selection of basic blocks.
-    void InvalidateBasicBlocks(const boost::container::unordered_flat_set<IR::LocationDescriptor>& locations);
+    void InvalidateBasicBlocks(const boost::unordered::unordered_flat_set<IR::LocationDescriptor>& locations);
 
 //protected:
     // Microinstruction emitters
@@ -132,8 +132,8 @@ public:
     // State
     BlockOfCode& code;
     ExceptionHandler exception_handler;
-    boost::container::unordered_flat_map<IR::LocationDescriptor, BlockDescriptor> block_descriptors;
-    boost::container::unordered_flat_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;

src/dynarmic/src/dynarmic/backend/x64/xbyak.h

@@ -7,8 +7,8 @@
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/unordered_map.hpp>
-#define XBYAK_STD_UNORDERED_SET boost::container::unordered_flat_set
-#define XBYAK_STD_UNORDERED_MAP boost::container::unordered_flat_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>

src/dynarmic/src/dynarmic/ir/opt_passes.cpp

@@ -1434,7 +1434,7 @@ static void VerificationPass(const IR::Block& block) {
             ASSERT(IR::AreTypesCompatible(t1, t2));
         }
     }
-    boost::container::unordered_flat_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())

src/dynarmic/tests/A64/fibonacci.cpp

@@ -24,7 +24,7 @@ namespace {
 class MyEnvironment final : public A64::UserCallbacks {
 public:
     u64 ticks_left = 0;
-    boost::container::unordered_flat_map<u64, u8> memory{};
+    boost::unordered::unordered_flat_map<u64, u8> memory{};
 
     u8 MemoryRead8(u64 vaddr) override {
         return memory[vaddr];

src/dynarmic/tests/A64/testenv.h

@@ -18,7 +18,7 @@ using Vector = Dynarmic::A64::Vector;
 
 class A64TestEnv : public Dynarmic::A64::UserCallbacks {
 public:
-    boost::container::unordered_flat_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;

src/hid_core/frontend/emulated_console.h

@@ -186,7 +186,7 @@ private:
 
     mutable std::mutex mutex;
     mutable std::mutex callback_mutex;
-    boost::container::unordered_flat_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

src/hid_core/frontend/emulated_controller.h

@@ -637,7 +637,7 @@ private:
     ControllerMotionDevices virtual_motion_devices;
 
     mutable std::mutex callback_mutex;
-    boost::container::unordered_flat_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

src/hid_core/frontend/emulated_devices.h

@@ -206,7 +206,7 @@ private:
 
     mutable std::mutex mutex;
     mutable std::mutex callback_mutex;
-    boost::container::unordered_flat_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

src/input_common/drivers/android.h

@@ -90,7 +90,7 @@ public:
     Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
 
 private:
-    boost::container::unordered_flat_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;

src/input_common/drivers/sdl_driver.cpp

@@ -732,7 +732,7 @@ SDLDriver::~SDLDriver() {
 
 std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
     std::vector<Common::ParamPackage> devices;
-    boost::container::unordered_flat_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()) {

src/input_common/drivers/sdl_driver.h

@@ -118,7 +118,7 @@ private:
     Common::SPSCQueue<VibrationRequest> vibration_queue;
 
     /// Map of GUID of a list of corresponding virtual Joysticks
-    boost::container::unordered_flat_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;

src/input_common/input_engine.h

@@ -301,8 +301,8 @@ private:
     bool configuring{false};
     const std::string input_engine;
     int last_callback_key = 0;
-    boost::container::unordered_flat_map<PadIdentifier, ControllerData> controller_list;
-    boost::container::unordered_flat_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;
 };
 

src/input_common/main.h

@@ -57,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 = boost::container::unordered_flat_map<Settings::NativeAnalog::Values, Common::ParamPackage>;
-using ButtonMapping = boost::container::unordered_flat_map<Settings::NativeButton::Values, Common::ParamPackage>;
-using MotionMapping = boost::container::unordered_flat_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:

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -371,7 +371,7 @@ public:
     Id load_const_func_u32x4{};
 
     // Sirit::Id doesn't play nice with *::set<>
-    boost::container::unordered_flat_set<u32> non_uniform_ids;
+    boost::unordered::unordered_flat_set<u32> non_uniform_ids;
 
     bool uses_nonuniform_sampled_image{};
     bool uses_nonuniform_storage_image{};

src/shader_recompiler/environment.h

@@ -127,9 +127,9 @@ protected:
     u32 start_address{};
     bool is_proprietary_driver{};
 public:
-    boost::container::unordered_flat_map<CbufWordKey, u32, CbufWordKeyHash> cbuf_word_cache;
-    boost::container::unordered_flat_map<HandleKey,  u32, HandleKeyHash> handle_cache;
-    boost::container::unordered_flat_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

src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp

@@ -391,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};
-        boost::container::unordered_flat_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) {

src/tests/common/fibers.cpp

@@ -40,7 +40,7 @@ public:
 
 private:
     mutable std::mutex mutex;
-    boost::container::unordered_flat_map<std::thread::id, u32> ids;
+    boost::unordered::unordered_flat_map<std::thread::id, u32> ids;
 };
 
 class TestControl1 {

src/tests/video_core/memory_tracker.cpp

@@ -66,7 +66,7 @@ public:
     }
 
 private:
-    boost::container::unordered_flat_map<u64, int> page_table;
+    boost::unordered::unordered_flat_map<u64, int> page_table;
     std::vector<std::tuple<DAddr, u64, int>> calls;
     size_t update_calls = 0;
 };

src/video_core/buffer_cache/memory_tracker_base.h

@@ -258,7 +258,7 @@ private:
     std::array<Manager*, NUM_HIGH_PAGES> top_tier{};
     std::deque<std::array<Manager, MANAGER_POOL_SIZE>> manager_pool;
     std::deque<Manager*> free_managers;
-    boost::container::unordered_flat_set<u32> cached_pages;
+    boost::unordered::unordered_flat_set<u32> cached_pages;
     DeviceTracker* device_tracker = nullptr;
 };
 

src/video_core/control/channel_state_cache.h

@@ -89,14 +89,14 @@ protected:
 
     std::deque<P> channel_storage;
     std::deque<size_t> free_channel_ids;
-    boost::container::unordered_flat_map<s32, size_t> channel_map;
+    boost::unordered::unordered_flat_map<s32, size_t> channel_map;
     std::vector<size_t> active_channel_ids;
     struct AddressSpaceRef {
         size_t ref_count;
         size_t storage_id;
         Tegra::MemoryManager* gpu_memory;
     };
-    boost::container::unordered_flat_map<size_t, AddressSpaceRef> address_spaces;
+    boost::unordered::unordered_flat_map<size_t, AddressSpaceRef> address_spaces;
     mutable std::mutex config_mutex;
 
     virtual void OnGPUASRegister([[maybe_unused]] size_t map_id) {}

src/video_core/control/scheduler.h

@@ -28,7 +28,7 @@ public:
     void DeclareChannel(std::shared_ptr<ChannelState> new_channel);
 
 private:
-    boost::container::unordered_flat_map<s32, std::shared_ptr<ChannelState>> channels;
+    boost::unordered::unordered_flat_map<s32, std::shared_ptr<ChannelState>> channels;
     std::mutex scheduling_guard;
 };
 

src/video_core/engines/maxwell_3d.h

@@ -3111,7 +3111,7 @@ public:
 
     void SetHLEReplacementAttributeType(u32 bank, u32 offset, HLEReplacementAttributeType name);
 
-    boost::container::unordered_flat_map<u64, HLEReplacementAttributeType> replace_table;
+    boost::unordered::unordered_flat_map<u64, HLEReplacementAttributeType> replace_table;
 
     static_assert(sizeof(Regs) == Regs::NUM_REGS * sizeof(u32), "Maxwell3D Regs has wrong size");
     static_assert(std::is_trivially_copyable_v<Regs>, "Maxwell3D Regs must be trivially copyable");

src/video_core/engines/sw_blitter/converter.cpp

@@ -925,7 +925,7 @@ public:
 };
 
 struct ConverterFactory::ConverterFactoryImpl {
-    boost::container::unordered_flat_map<RenderTargetFormat, std::unique_ptr<Converter>> converters_cache;
+    boost::unordered::unordered_flat_map<RenderTargetFormat, std::unique_ptr<Converter>> converters_cache;
 };
 
 ConverterFactory::ConverterFactory() {

src/video_core/gpu.cpp

@@ -333,7 +333,7 @@ struct GPU::Impl {
     std::unique_ptr<Core::Frontend::GraphicsContext> cpu_context;
 
     Tegra::Control::Scheduler scheduler;
-    boost::container::unordered_flat_map<s32, std::shared_ptr<Tegra::Control::ChannelState>> channels;
+    boost::unordered::unordered_flat_map<s32, std::shared_ptr<Tegra::Control::ChannelState>> channels;
     Tegra::Control::ChannelState* current_channel;
     s32 bound_channel{-1};
 

src/video_core/gpu_logging/gpu_logging.h

@@ -153,7 +153,7 @@ private:
     mutable std::mutex ring_buffer_mutex;
 
     // Memory tracking
-    boost::container::unordered_flat_map<uintptr_t, MemoryAllocationEntry> memory_allocations;
+    boost::unordered::unordered_flat_map<uintptr_t, MemoryAllocationEntry> memory_allocations;
     mutable std::mutex memory_mutex;
 
     // Statistics

src/video_core/host1x/host1x.h

@@ -119,7 +119,7 @@ private:
     }
 
     std::mutex m_mutex{};
-    boost::container::unordered_flat_map<s32, FrameDevice> m_frame_devices;
+    boost::unordered::unordered_flat_map<s32, FrameDevice> m_frame_devices;
 
     static constexpr size_t MAX_PRESENT_QUEUE = 100;
     static constexpr size_t MAX_DECODE_MAP = 200;

src/video_core/macro.h

@@ -238,8 +238,8 @@ struct MacroEngine {
         AnyCachedMacro program;
         u64 hash{};
     };
-    boost::container::unordered_flat_map<u32, CacheInfo> macro_cache;
-    boost::container::unordered_flat_map<u32, std::vector<u32>> uploaded_macro_code;
+    boost::unordered::unordered_flat_map<u32, CacheInfo> macro_cache;
+    boost::unordered::unordered_flat_map<u32, std::vector<u32>> uploaded_macro_code;
     bool is_interpreted;
 };
 

src/video_core/query_cache.h

@@ -351,7 +351,7 @@ private:
 
     mutable std::recursive_mutex mutex;
 
-    boost::container::unordered_flat_map<u64, std::vector<CachedQuery>> cached_queries;
+    boost::unordered::unordered_flat_map<u64, std::vector<CachedQuery>> cached_queries;
 
     std::array<CounterStream, VideoCore::NumQueryTypes> streams;
 

src/video_core/query_cache/query_cache_base.h

@@ -161,7 +161,7 @@ protected:
         }
     }
 
-    using ContentCache = boost::container::unordered_flat_map<u64, boost::container::unordered_flat_map<u32, QueryLocation>>;
+    using ContentCache = boost::unordered::unordered_flat_map<u64, boost::unordered::unordered_flat_map<u32, QueryLocation>>;
 
     void InvalidateQuery(QueryLocation location);
     bool IsQueryDirty(QueryLocation location);
@@ -169,7 +169,7 @@ protected:
     void RequestGuestHostSync();
     void UnregisterPending();
 
-    boost::container::unordered_flat_map<u64, boost::container::unordered_flat_map<u32, QueryLocation>> cached_queries;
+    boost::unordered::unordered_flat_map<u64, boost::unordered::unordered_flat_map<u32, QueryLocation>> cached_queries;
     std::mutex cache_mutex;
 
     struct QueryCacheBaseImpl;

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -243,7 +243,7 @@ private:
     u32 index_buffer_offset = 0;
 
     u64 device_access_memory;
-    boost::container::unordered_flat_map<GPUVAddr, OGLTransformFeedback> tfb_objects;
+    boost::unordered::unordered_flat_map<GPUVAddr, OGLTransformFeedback> tfb_objects;
 };
 
 struct BufferCacheParams {

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -82,8 +82,8 @@ private:
     GraphicsPipeline* current_pipeline{};
 
     ShaderContext::ShaderPools main_pools;
-    boost::container::unordered_flat_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
-    boost::container::unordered_flat_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>> compute_cache;
+    boost::unordered::unordered_flat_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
+    boost::unordered::unordered_flat_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>> compute_cache;
 
     Shader::Profile profile;
     Shader::HostTranslateInfo host_info;

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -159,7 +159,7 @@ private:
     UtilShaders util_shaders;
     FormatConversionPass format_conversion_pass;
 
-    std::array<boost::container::unordered_flat_map<GLenum, FormatProperties>, 3> format_properties;
+    std::array<boost::unordered::unordered_flat_map<GLenum, FormatProperties>, 3> format_properties;
     bool has_broken_texture_view_formats = false;
 
     OGLTexture null_image_1d_array;

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -164,8 +164,8 @@ private:
     GraphicsPipelineCacheKey graphics_key{};
     GraphicsPipeline* current_pipeline{};
 
-    boost::container::unordered_flat_map<ComputePipelineCacheKey, std::unique_ptr<ComputePipeline>> compute_cache;
-    boost::container::unordered_flat_map<GraphicsPipelineCacheKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
+    boost::unordered::unordered_flat_map<ComputePipelineCacheKey, std::unique_ptr<ComputePipeline>> compute_cache;
+    boost::unordered::unordered_flat_map<GraphicsPipelineCacheKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
 
     ShaderPools main_pools;
 

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -247,7 +247,7 @@ public:
         sync_values_stash.emplace_back();
         std::vector<HostSyncValues>* sync_values = &sync_values_stash.back();
         sync_values->reserve(num_slots_used);
-        boost::container::unordered_flat_map<size_t, std::pair<size_t, size_t>> offsets;
+        boost::unordered::unordered_flat_map<size_t, std::pair<size_t, size_t>> offsets;
         resolve_buffers.clear();
         size_t resolve_buffer_index = ObtainBuffer<true>(num_slots_used);
         resolve_buffers.push_back(resolve_buffer_index);
@@ -429,7 +429,7 @@ private:
     template <bool is_ordered, typename Func>
     void ApplyBanksWideOp(std::vector<size_t>& queries, Func&& func) {
         std::conditional_t<is_ordered, std::map<size_t, std::pair<size_t, size_t>>,
-                           boost::container::unordered_flat_map<size_t, std::pair<size_t, size_t>>>
+                           boost::unordered::unordered_flat_map<size_t, std::pair<size_t, size_t>>>
             indexer;
         for (auto q : queries) {
             auto* query = GetQuery(q);
@@ -758,7 +758,7 @@ public:
 
     void SyncWrites() override {
         CloseCounter();
-        boost::container::unordered_flat_map<size_t, std::vector<HostSyncValues>> sync_values_stash;
+        boost::unordered::unordered_flat_map<size_t, std::vector<HostSyncValues>> sync_values_stash;
         for (auto q : pending_sync) {
             auto* query = GetQuery(q);
             if (True(query->flags & VideoCommon::QueryFlagBits::IsRewritten)) {

src/video_core/renderer_vulkan/vk_render_pass_cache.h

@@ -76,7 +76,7 @@ public:
 
 private:
     const Device* device{};
-    boost::container::unordered_flat_map<RenderPassKey, vk::RenderPass> cache;
+    boost::unordered::unordered_flat_map<RenderPassKey, vk::RenderPass> cache;
     std::mutex mutex;
 };
 

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -186,7 +186,7 @@ public:
     };
 
     std::vector<MsaaScratchImage> msaa_scratch_images;
-    boost::container::unordered_flat_map<VkImage, ResolveShadow> resolve_shadows;
+    boost::unordered::unordered_flat_map<VkImage, ResolveShadow> resolve_shadows;
     std::vector<std::pair<u64, ResolveShadow>> pending_resolve_shadows;
 };
 

src/video_core/shader_cache.h

@@ -149,8 +149,8 @@ private:
     mutable std::mutex lookup_mutex;
     std::mutex invalidation_mutex;
 
-    boost::container::unordered_flat_map<u64, std::unique_ptr<Entry>> lookup_cache;
-    boost::container::unordered_flat_map<u64, std::vector<Entry*>> invalidation_cache;
+    boost::unordered::unordered_flat_map<u64, std::unique_ptr<Entry>> lookup_cache;
+    boost::unordered::unordered_flat_map<u64, std::vector<Entry*>> invalidation_cache;
     std::vector<std::unique_ptr<ShaderInfo>> storage;
     std::vector<Entry*> marked_for_removal;
 };

src/video_core/shader_environment.h

@@ -80,10 +80,10 @@ protected:
     GPUVAddr program_base{};
 
     std::vector<u64> code;
-    boost::container::unordered_flat_map<u32, Shader::TextureType> texture_types;
-    boost::container::unordered_flat_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
-    boost::container::unordered_flat_map<u64, u32> cbuf_values;
-    boost::container::unordered_flat_map<u64, Shader::ReplaceConstant> cbuf_replacements;
+    boost::unordered::unordered_flat_map<u32, Shader::TextureType> texture_types;
+    boost::unordered::unordered_flat_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
+    boost::unordered::unordered_flat_map<u64, u32> cbuf_values;
+    boost::unordered::unordered_flat_map<u64, Shader::ReplaceConstant> cbuf_replacements;
 
     u32 local_memory_size{};
     u32 texture_bound{};
@@ -202,10 +202,10 @@ public:
 
 private:
     std::vector<u64> code;
-    boost::container::unordered_flat_map<u32, Shader::TextureType> texture_types;
-    boost::container::unordered_flat_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
-    boost::container::unordered_flat_map<u64, u32> cbuf_values;
-    boost::container::unordered_flat_map<u64, Shader::ReplaceConstant> cbuf_replacements;
+    boost::unordered::unordered_flat_map<u32, Shader::TextureType> texture_types;
+    boost::unordered::unordered_flat_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
+    boost::unordered::unordered_flat_map<u64, u32> cbuf_values;
+    boost::unordered::unordered_flat_map<u64, Shader::ReplaceConstant> cbuf_replacements;
     std::array<u32, 3> workgroup_size{};
     u32 local_memory_size{};
     u32 shared_memory_size{};

src/video_core/texture_cache/texture_cache.h

@@ -2191,7 +2191,7 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
     image.flags &= ~ImageFlagBits::BadOverlap;
     lru_cache.Free(image.lru_index);
     const auto& clear_page_table =
-        [image_id](u64 page, boost::container::unordered_flat_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>& selected_page_table) {
+        [image_id](u64 page, boost::unordered::unordered_flat_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>& selected_page_table) {
             const auto page_it = selected_page_table.find(page);
             if (page_it == selected_page_table.end()) {
                 ASSERT_MSG(false, "Unregistering unregistered page={:#x}", page << YUZU_PAGEBITS);

src/video_core/texture_cache/texture_cache_base.h

@@ -69,7 +69,7 @@ struct AsyncDecodeContext {
     std::atomic_bool complete;
 };
 
-using TextureCacheGPUMap = boost::container::unordered_flat_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>;
+using TextureCacheGPUMap = boost::unordered::unordered_flat_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>;
 
 class TextureCacheChannelInfo : public ChannelInfo {
 public:
@@ -87,8 +87,8 @@ public:
     std::unordered_map<TICEntry, ImageViewId> image_views;
     std::unordered_map<TSCEntry, SamplerId> samplers;
 
-    boost::container::unordered_flat_map<u32, SamplerId> sampler_ids;
-    boost::container::unordered_flat_map<u32, ImageViewId> image_view_ids;
+    boost::unordered::unordered_flat_map<u32, SamplerId> sampler_ids;
+    boost::unordered::unordered_flat_map<u32, ImageViewId> image_view_ids;
 
     TextureCacheGPUMap* gpu_page_table = nullptr;
     TextureCacheGPUMap* sparse_page_table = nullptr;
@@ -442,9 +442,9 @@ private:
     FramebufferId last_framebuffer_id{};
     u64 last_framebuffer_serial = 0;
 
-    boost::container::unordered_flat_map<RenderTargets, FramebufferId> framebuffers;
-    boost::container::unordered_flat_map<u64, std::vector<ImageMapId>, Common::IdentityHash<u64>> page_table;
-    boost::container::unordered_flat_map<ImageId, boost::container::small_vector<ImageViewId, 16>> sparse_views;
+    boost::unordered::unordered_flat_map<RenderTargets, FramebufferId> framebuffers;
+    boost::unordered::unordered_flat_map<u64, std::vector<ImageMapId>, Common::IdentityHash<u64>> page_table;
+    boost::unordered::unordered_flat_map<ImageId, boost::container::small_vector<ImageViewId, 16>> sparse_views;
 
     DAddr virtual_invalid_space{};
 
@@ -500,7 +500,7 @@ private:
     DelayedDestructionRing<ImageView, TICKS_TO_DESTROY> sentenced_image_view;
     DelayedDestructionRing<Framebuffer, TICKS_TO_DESTROY> sentenced_framebuffers;
 
-    boost::container::unordered_flat_map<GPUVAddr, ImageAllocId> image_allocs_table;
+    boost::unordered::unordered_flat_map<GPUVAddr, ImageAllocId> image_allocs_table;
 
     Common::ScratchBuffer<u8> swizzle_data_buffer;
     Common::ScratchBuffer<u8> unswizzle_data_buffer;
@@ -517,17 +517,17 @@ private:
 
     // Join caching
     boost::container::small_vector<ImageId, 4> join_overlap_ids;
-    boost::container::unordered_flat_set<ImageId> join_overlaps_found;
+    boost::unordered::unordered_flat_set<ImageId> join_overlaps_found;
     boost::container::small_vector<ImageId, 4> join_left_aliased_ids;
     boost::container::small_vector<ImageId, 4> join_right_aliased_ids;
-    boost::container::unordered_flat_set<ImageId> join_ignore_textures;
+    boost::unordered::unordered_flat_set<ImageId> join_ignore_textures;
     boost::container::small_vector<ImageId, 4> join_bad_overlap_ids;
     struct JoinCopy {
         bool is_alias;
         ImageId id;
     };
     boost::container::small_vector<JoinCopy, 4> join_copies_to_do;
-    boost::container::unordered_flat_map<ImageId, size_t> join_alias_indices;
+    boost::unordered::unordered_flat_map<ImageId, size_t> join_alias_indices;
 };
 
 } // namespace VideoCommon

src/video_core/vulkan_common/vulkan_device.cpp

@@ -158,7 +158,7 @@ VkFormatFeatureFlags GetFormatFeatures(VkFormatProperties properties, FormatType
     }
 }
 
-boost::container::unordered_flat_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::PhysicalDevice physical) {
+boost::unordered::unordered_flat_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::PhysicalDevice physical) {
     static constexpr std::array formats{
         VK_FORMAT_A1R5G5B5_UNORM_PACK16,
         VK_FORMAT_A2B10G10R10_SINT_PACK32,
@@ -310,7 +310,7 @@ boost::container::unordered_flat_map<VkFormat, VkFormatProperties> GetFormatProp
         VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
         VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
     };
-    boost::container::unordered_flat_map<VkFormat, VkFormatProperties> format_properties;
+    boost::unordered::unordered_flat_map<VkFormat, VkFormatProperties> format_properties;
     for (const auto format : formats) {
         format_properties.emplace(format, physical.GetFormatProperties(format));
     }
@@ -318,7 +318,7 @@ boost::container::unordered_flat_map<VkFormat, VkFormatProperties> GetFormatProp
 }
 
 #if defined(__ANDROID__) && defined(ARCHITECTURE_arm64)
-void OverrideBcnFormats(boost::container::unordered_flat_map<VkFormat, VkFormatProperties>& format_properties) {
+void OverrideBcnFormats(boost::unordered::unordered_flat_map<VkFormat, VkFormatProperties>& format_properties) {
     // These properties are extracted from Adreno driver 512.687.0
     constexpr VkFormatFeatureFlags tiling_features{VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
                                                    VK_FORMAT_FEATURE_BLIT_SRC_BIT |
@@ -1677,7 +1677,7 @@ void Device::CollectToolingInfo() {
 std::vector<VkDeviceQueueCreateInfo> Device::GetDeviceQueueCreateInfos() const {
     static constexpr float QUEUE_PRIORITY = 1.0f;
 
-    boost::container::unordered_flat_set<u32> unique_queue_families{graphics_family, present_family};
+    boost::unordered::unordered_flat_set<u32> unique_queue_families{graphics_family, present_family};
     std::vector<VkDeviceQueueCreateInfo> queue_cis;
     queue_cis.reserve(unique_queue_families.size());
 

src/video_core/vulkan_common/vulkan_device.h

@@ -1242,7 +1242,7 @@ private:
     std::vector<size_t> valid_heap_memory;                   ///< Heaps used.
 
     /// Format properties dictionary.
-    boost::container::unordered_flat_map<VkFormat, VkFormatProperties> format_properties;
+    boost::unordered::unordered_flat_map<VkFormat, VkFormatProperties> format_properties;
 
     /// Nsight Aftermath GPU crash tracker
     std::unique_ptr<NsightAftermathTracker> nsight_aftermath_tracker;

src/yuzu/configuration/input_profiles.h

@@ -36,5 +36,5 @@ public:
 private:
     bool ProfileExistsInMap(const std::string& profile_name) const;
 
-    boost::container::unordered_flat_map<std::string, std::unique_ptr<QtConfig>> map_profiles;
+    boost::unordered::unordered_flat_map<std::string, std::unique_ptr<QtConfig>> map_profiles;
 };

src/yuzu/loading_screen.h

@@ -80,8 +80,8 @@ private:
     std::unique_ptr<QPropertyAnimation> fadeout_animation;
 
     // Definitions for the differences in text and styling for each stage
-    boost::container::unordered_flat_map<VideoCore::LoadCallbackStage, const char*> progressbar_style;
-    boost::container::unordered_flat_map<VideoCore::LoadCallbackStage, QString> stage_translations;
+    boost::unordered::unordered_flat_map<VideoCore::LoadCallbackStage, const char*> progressbar_style;
+    boost::unordered::unordered_flat_map<VideoCore::LoadCallbackStage, QString> stage_translations;
 
     // newly generated shaders are added to the end of the file, so when loading and compiling
     // shaders, it will start quickly but end slow if new shaders were added since previous launch.

src/yuzu/multiplayer/chat_room.h

@@ -66,8 +66,8 @@ private:
     bool has_mod_perms = false;
     QStandardItemModel* player_list;
     std::unique_ptr<Ui::ChatRoom> ui;
-    boost::container::unordered_flat_set<std::string> block_list;
-    boost::container::unordered_flat_map<std::string, QPixmap> icon_cache;
+    boost::unordered::unordered_flat_set<std::string> block_list;
+    boost::unordered::unordered_flat_map<std::string, QPixmap> icon_cache;
 };
 
 Q_DECLARE_METATYPE(Network::ChatEntry);