67 files changed, 1390 insertions, 1442 deletions
diff --git a/.gitmodules b/.gitmodules
index 2c044ed7d..a33a04167 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,9 +13,6 @@
 [submodule "dynarmic"]
    path = externals/dynarmic
    url = https://github.com/MerryMage/dynarmic.git
-[submodule "xbyak"]
-    path = externals/xbyak
-    url = https://github.com/herumi/xbyak.git
 [submodule "fmt"]
    path = externals/fmt
    url = https://github.com/fmtlib/fmt.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 918cf5372..1f71f9fd9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -377,7 +377,7 @@ if (CLANG_FORMAT)
    set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
    if (WIN32)
        add_custom_target(clang-format
-            COMMAND powershell.exe -Command "${CLANG_FORMAT} -i @(Get-ChildItem -Recurse ${SRCS}/* -Include \'*.h\', \'*.cpp\')"
+            COMMAND powershell.exe -Command "Get-ChildItem ${SRCS}/* -Include *.cpp,*.h -Recurse | Foreach {${CLANG_FORMAT} -i $_.fullname}"
            COMMENT ${CCOMMENT})
    elseif(MINGW)
        add_custom_target(clang-format
diff --git a/externals/CMakeLists.txt b/externals/CMakeLists.txt
index 1261062e8..e156bbece 100644
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -9,7 +9,6 @@ target_include_directories(catch-single-include INTERFACE catch/single_include)
 # Dynarmic
 if (ARCHITECTURE_x86_64)
-    add_library(xbyak INTERFACE)
    set(DYNARMIC_TESTS OFF)
    set(DYNARMIC_NO_BUNDLED_FMT ON)
    add_subdirectory(dynarmic)
@@ -53,14 +52,6 @@ target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 # SoundTouch
 add_subdirectory(soundtouch)
-# Xbyak
-if (ARCHITECTURE_x86_64)
-    # Defined before "dynarmic" above
-    # add_library(xbyak INTERFACE)
-    target_include_directories(xbyak INTERFACE ./xbyak/xbyak)
-    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
-endif()
 # Opus
 add_subdirectory(opus)
 target_include_directories(opus INTERFACE ./opus/include)
diff --git a/externals/xbyak b/externals/xbyak
deleted file mode 160000
-Subproject 1de435ed04c8e74775804da944d176baf0ce56e
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index eccd8f64a..a5e71d879 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -44,7 +44,6 @@ add_library(common STATIC
    detached_tasks.cpp
    detached_tasks.h
    bit_field.h
-    bit_set.h
    cityhash.cpp
    cityhash.h
    color.h
@@ -95,14 +94,9 @@ if(ARCHITECTURE_x86_64)
        PRIVATE
            x64/cpu_detect.cpp
            x64/cpu_detect.h
-            x64/xbyak_abi.h
-            x64/xbyak_util.h
    )
 endif()
 create_target_directory_groups(common)
 target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
-if (ARCHITECTURE_x86_64)
-    target_link_libraries(common PRIVATE xbyak)
-endif()
diff --git a/src/common/assert.h b/src/common/assert.h
index 0d4eddc19..6002f7ab1 100644
--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -52,5 +52,8 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
-#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
+#define UNIMPLEMENTED() ASSERT_MSG(false, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
+#define UNIMPLEMENTED_IF(cond) ASSERT_MSG(!(cond), "Unimplemented code!")
+#define UNIMPLEMENTED_IF_MSG(cond, ...) ASSERT_MSG(!(cond), __VA_ARGS__)
diff --git a/src/common/bit_set.h b/src/common/bit_set.h
deleted file mode 100644
index 5cd1352b2..000000000
--- a/src/common/bit_set.h
+++ /dev/null
@@ -1,244 +0,0 @@
-// This file is under the public domain.
-#pragma once
-#include <cstddef>
-#ifdef _WIN32
-#include <intrin.h>
-#endif
-#include <initializer_list>
-#include <new>
-#include <type_traits>
-#include "common/common_types.h"
-// namespace avoids conflict with OS X Carbon; don't use BitSet<T> directly
-namespace Common {
-// Helper functions:
-#ifdef _MSC_VER
-template <typename T>
-static inline int CountSetBits(T v) {
-    // from https://graphics.stanford.edu/~seander/bithacks.html
-    // GCC has this built in, but MSVC's intrinsic will only emit the actual
-    // POPCNT instruction, which we're not depending on
-    v = v - ((v >> 1) & (T) ~(T)0 / 3);
-    v = (v & (T) ~(T)0 / 15 * 3) + ((v >> 2) & (T) ~(T)0 / 15 * 3);
-    v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15;
-    return (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;
-}
-static inline int LeastSignificantSetBit(u8 val) {
-    unsigned long index;
-    _BitScanForward(&index, val);
-    return (int)index;
-}
-static inline int LeastSignificantSetBit(u16 val) {
-    unsigned long index;
-    _BitScanForward(&index, val);
-    return (int)index;
-}
-static inline int LeastSignificantSetBit(u32 val) {
-    unsigned long index;
-    _BitScanForward(&index, val);
-    return (int)index;
-}
-static inline int LeastSignificantSetBit(u64 val) {
-    unsigned long index;
-    _BitScanForward64(&index, val);
-    return (int)index;
-}
-#else
-static inline int CountSetBits(u8 val) {
-    return __builtin_popcount(val);
-}
-static inline int CountSetBits(u16 val) {
-    return __builtin_popcount(val);
-}
-static inline int CountSetBits(u32 val) {
-    return __builtin_popcount(val);
-}
-static inline int CountSetBits(u64 val) {
-    return __builtin_popcountll(val);
-}
-static inline int LeastSignificantSetBit(u8 val) {
-    return __builtin_ctz(val);
-}
-static inline int LeastSignificantSetBit(u16 val) {
-    return __builtin_ctz(val);
-}
-static inline int LeastSignificantSetBit(u32 val) {
-    return __builtin_ctz(val);
-}
-static inline int LeastSignificantSetBit(u64 val) {
-    return __builtin_ctzll(val);
-}
-#endif
-// Similar to std::bitset, this is a class which encapsulates a bitset, i.e.
-// using the set bits of an integer to represent a set of integers.  Like that
-// class, it acts like an array of bools:
-//     BitSet32 bs;
-//     bs[1] = true;
-// but also like the underlying integer ([0] = least significant bit):
-//     BitSet32 bs2 = ...;
-//     bs = (bs ^ bs2) & BitSet32(0xffff);
-// The following additional functionality is provided:
-// - Construction using an initializer list.
-//     BitSet bs { 1, 2, 4, 8 };
-// - Efficiently iterating through the set bits:
-//     for (int i : bs)
-//         [i is the *index* of a set bit]
-//   (This uses the appropriate CPU instruction to find the next set bit in one
-//   operation.)
-// - Counting set bits using .Count() - see comment on that method.
-// TODO: use constexpr when MSVC gets out of the Dark Ages
-template <typename IntTy>
-class BitSet {
-    static_assert(!std::is_signed_v<IntTy>, "BitSet should not be used with signed types");
-public:
-    // A reference to a particular bit, returned from operator[].
-    class Ref {
-    public:
-        Ref(Ref&& other) : m_bs(other.m_bs), m_mask(other.m_mask) {}
-        Ref(BitSet* bs, IntTy mask) : m_bs(bs), m_mask(mask) {}
-        operator bool() const {
-            return (m_bs->m_val & m_mask) != 0;
-        }
-        bool operator=(bool set) {
-            m_bs->m_val = (m_bs->m_val & ~m_mask) | (set ? m_mask : 0);
-            return set;
-        }
-    private:
-        BitSet* m_bs;
-        IntTy m_mask;
-    };
-    // A STL-like iterator is required to be able to use range-based for loops.
-    class Iterator {
-    public:
-        Iterator(const Iterator& other) : m_val(other.m_val), m_bit(other.m_bit) {}
-        Iterator(IntTy val) : m_val(val), m_bit(0) {}
-        Iterator& operator=(Iterator other) {
-            new (this) Iterator(other);
-            return *this;
-        }
-        int operator*() {
-            return m_bit + ComputeLsb();
-        }
-        Iterator& operator++() {
-            int lsb = ComputeLsb();
-            m_val >>= lsb + 1;
-            m_bit += lsb + 1;
-            m_has_lsb = false;
-            return *this;
-        }
-        Iterator operator++(int _) {
-            Iterator other(*this);
-            ++*this;
-            return other;
-        }
-        bool operator==(Iterator other) const {
-            return m_val == other.m_val;
-        }
-        bool operator!=(Iterator other) const {
-            return m_val != other.m_val;
-        }
-    private:
-        int ComputeLsb() {
-            if (!m_has_lsb) {
-                m_lsb = LeastSignificantSetBit(m_val);
-                m_has_lsb = true;
-            }
-            return m_lsb;
-        }
-        IntTy m_val;
-        int m_bit;
-        int m_lsb = -1;
-        bool m_has_lsb = false;
-    };
-    BitSet() : m_val(0) {}
-    explicit BitSet(IntTy val) : m_val(val) {}
-    BitSet(std::initializer_list<int> init) {
-        m_val = 0;
-        for (int bit : init)
-            m_val |= (IntTy)1 << bit;
-    }
-    static BitSet AllTrue(std::size_t count) {
-        return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1));
-    }
-    Ref operator[](std::size_t bit) {
-        return Ref(this, (IntTy)1 << bit);
-    }
-    const Ref operator[](std::size_t bit) const {
-        return (*const_cast<BitSet*>(this))[bit];
-    }
-    bool operator==(BitSet other) const {
-        return m_val == other.m_val;
-    }
-    bool operator!=(BitSet other) const {
-        return m_val != other.m_val;
-    }
-    bool operator<(BitSet other) const {
-        return m_val < other.m_val;
-    }
-    bool operator>(BitSet other) const {
-        return m_val > other.m_val;
-    }
-    BitSet operator|(BitSet other) const {
-        return BitSet(m_val | other.m_val);
-    }
-    BitSet operator&(BitSet other) const {
-        return BitSet(m_val & other.m_val);
-    }
-    BitSet operator^(BitSet other) const {
-        return BitSet(m_val ^ other.m_val);
-    }
-    BitSet operator~() const {
-        return BitSet(~m_val);
-    }
-    BitSet& operator|=(BitSet other) {
-        return *this = *this | other;
-    }
-    BitSet& operator&=(BitSet other) {
-        return *this = *this & other;
-    }
-    BitSet& operator^=(BitSet other) {
-        return *this = *this ^ other;
-    }
-    operator u32() = delete;
-    operator bool() {
-        return m_val != 0;
-    }
-    // Warning: Even though on modern CPUs this is a single fast instruction,
-    // Dolphin's official builds do not currently assume POPCNT support on x86,
-    // so slower explicit bit twiddling is generated.  Still should generally
-    // be faster than a loop.
-    unsigned int Count() const {
-        return CountSetBits(m_val);
-    }
-    Iterator begin() const {
-        return Iterator(m_val);
-    }
-    Iterator end() const {
-        return Iterator(0);
-    }
-    IntTy m_val;
-};
-} // namespace Common
-typedef Common::BitSet<u8> BitSet8;
-typedef Common::BitSet<u16> BitSet16;
-typedef Common::BitSet<u32> BitSet32;
-typedef Common::BitSet<u64> BitSet64;
diff --git a/src/common/math_util.h b/src/common/math_util.h
index 343cdd902..94b4394c5 100644
--- a/src/common/math_util.h
+++ b/src/common/math_util.h
@@ -4,18 +4,12 @@
 #pragma once
-#include <algorithm>
 #include <cstdlib>
 #include <type_traits>
 namespace MathUtil {
-static constexpr float PI = 3.14159265f;
+constexpr float PI = 3.14159265f;
-inline bool IntervalsIntersect(unsigned start0, unsigned length0, unsigned start1,
-                               unsigned length1) {
-    return (std::max(start0, start1) < std::min(start0 + length0, start1 + length1));
-}
 template <class T>
 struct Rectangle {
@@ -24,16 +18,16 @@ struct Rectangle {
    T right{};
    T bottom{};
-    Rectangle() = default;
+    constexpr Rectangle() = default;
-    Rectangle(T left, T top, T right, T bottom)
+    constexpr Rectangle(T left, T top, T right, T bottom)
        : left(left), top(top), right(right), bottom(bottom) {}
    T GetWidth() const {
-        return std::abs(static_cast<typename std::make_signed<T>::type>(right - left));
+        return std::abs(static_cast<std::make_signed_t<T>>(right - left));
    }
    T GetHeight() const {
-        return std::abs(static_cast<typename std::make_signed<T>::type>(bottom - top));
+        return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
    }
    Rectangle<T> TranslateX(const T x) const {
        return Rectangle{left + x, top, right + x, bottom};
diff --git a/src/common/thread.cpp b/src/common/thread.cpp
index 9e207118f..5144c0d9f 100644
--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -25,23 +25,6 @@
 namespace Common {
-int CurrentThreadId() {
-#ifdef _MSC_VER
-    return GetCurrentThreadId();
-#elif defined __APPLE__
-    return mach_thread_self();
-#else
-    return 0;
-#endif
-}
-#ifdef _WIN32
-// Supporting functions
-void SleepCurrentThread(int ms) {
-    Sleep(ms);
-}
-#endif
 #ifdef _MSC_VER
 void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask) {
@@ -62,7 +45,7 @@ void SwitchCurrentThread() {
 // This is implemented much nicer in upcoming msvc++, see:
 // http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
-void SetCurrentThreadName(const char* szThreadName) {
+void SetCurrentThreadName(const char* name) {
    static const DWORD MS_VC_EXCEPTION = 0x406D1388;
 #pragma pack(push, 8)
@@ -75,7 +58,7 @@ void SetCurrentThreadName(const char* szThreadName) {
 #pragma pack(pop)
    info.dwType = 0x1000;
-    info.szName = szThreadName;
+    info.szName = name;
    info.dwThreadID = -1; // dwThreadID;
    info.dwFlags = 0;
@@ -107,10 +90,6 @@ void SetCurrentThreadAffinity(u32 mask) {
 }
 #ifndef _WIN32
-void SleepCurrentThread(int ms) {
-    usleep(1000 * ms);
-}
 void SwitchCurrentThread() {
    usleep(1000 * 1);
 }
@@ -118,15 +97,15 @@ void SwitchCurrentThread() {
 // MinGW with the POSIX threading model does not support pthread_setname_np
 #if !defined(_WIN32) || defined(_MSC_VER)
-void SetCurrentThreadName(const char* szThreadName) {
+void SetCurrentThreadName(const char* name) {
 #ifdef __APPLE__
-    pthread_setname_np(szThreadName);
+    pthread_setname_np(name);
 #elif defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-    pthread_set_name_np(pthread_self(), szThreadName);
+    pthread_set_name_np(pthread_self(), name);
 #elif defined(__NetBSD__)
-    pthread_setname_np(pthread_self(), "%s", (void*)szThreadName);
+    pthread_setname_np(pthread_self(), "%s", (void*)name);
 #else
-    pthread_setname_np(pthread_self(), szThreadName);
+    pthread_setname_np(pthread_self(), name);
 #endif
 }
 #endif
diff --git a/src/common/thread.h b/src/common/thread.h
index 6cbdb96a3..2cf74452d 100644
--- a/src/common/thread.h
+++ b/src/common/thread.h
@@ -13,15 +13,8 @@
 namespace Common {
-int CurrentThreadId();
-void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
-void SetCurrentThreadAffinity(u32 mask);
 class Event {
 public:
-    Event() : is_set(false) {}
    void Set() {
        std::lock_guard<std::mutex> lk(mutex);
        if (!is_set) {
@@ -53,14 +46,14 @@ public:
    }
 private:
-    bool is_set;
+    bool is_set = false;
    std::condition_variable condvar;
    std::mutex mutex;
 };
 class Barrier {
 public:
-    explicit Barrier(std::size_t count_) : count(count_), waiting(0), generation(0) {}
+    explicit Barrier(std::size_t count_) : count(count_) {}
    /// Blocks until all "count" threads have called Sync()
    void Sync() {
@@ -80,12 +73,13 @@ public:
 private:
    std::condition_variable condvar;
    std::mutex mutex;
-    const std::size_t count;
+    std::size_t count;
-    std::size_t waiting;
+    std::size_t waiting = 0;
-    std::size_t generation; // Incremented once each time the barrier is used
+    std::size_t generation = 0; // Incremented once each time the barrier is used
 };
-void SleepCurrentThread(int ms);
+void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
+void SetCurrentThreadAffinity(u32 mask);
 void SwitchCurrentThread(); // On Linux, this is equal to sleep 1ms
 void SetCurrentThreadName(const char* name);
diff --git a/src/common/x64/xbyak_abi.h b/src/common/x64/xbyak_abi.h
deleted file mode 100644
index 636a5c0f9..000000000
--- a/src/common/x64/xbyak_abi.h
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-#pragma once
-#include <initializer_list>
-#include <xbyak.h>
-#include "common/assert.h"
-#include "common/bit_set.h"
-namespace Common::X64 {
-inline int RegToIndex(const Xbyak::Reg& reg) {
-    using Kind = Xbyak::Reg::Kind;
-    ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
-               "RegSet only support GPRs and XMM registers.");
-    ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
-    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
-}
-inline Xbyak::Reg64 IndexToReg64(int reg_index) {
-    ASSERT(reg_index < 16);
-    return Xbyak::Reg64(reg_index);
-}
-inline Xbyak::Xmm IndexToXmm(int reg_index) {
-    ASSERT(reg_index >= 16 && reg_index < 32);
-    return Xbyak::Xmm(reg_index - 16);
-}
-inline Xbyak::Reg IndexToReg(int reg_index) {
-    if (reg_index < 16) {
-        return IndexToReg64(reg_index);
-    } else {
-        return IndexToXmm(reg_index);
-    }
-}
-inline BitSet32 BuildRegSet(std::initializer_list<Xbyak::Reg> regs) {
-    BitSet32 bits;
-    for (const Xbyak::Reg& reg : regs) {
-        bits[RegToIndex(reg)] = true;
-    }
-    return bits;
-}
-const BitSet32 ABI_ALL_GPRS(0x0000FFFF);
-const BitSet32 ABI_ALL_XMMS(0xFFFF0000);
-#ifdef _WIN32
-// Microsoft x64 ABI
-const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
-const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rcx;
-const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rdx;
-const Xbyak::Reg ABI_PARAM3 = Xbyak::util::r8;
-const Xbyak::Reg ABI_PARAM4 = Xbyak::util::r9;
-const BitSet32 ABI_ALL_CALLER_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rcx,
-    Xbyak::util::rdx,
-    Xbyak::util::r8,
-    Xbyak::util::r9,
-    Xbyak::util::r10,
-    Xbyak::util::r11,
-    // XMMs
-    Xbyak::util::xmm0,
-    Xbyak::util::xmm1,
-    Xbyak::util::xmm2,
-    Xbyak::util::xmm3,
-    Xbyak::util::xmm4,
-    Xbyak::util::xmm5,
-});
-const BitSet32 ABI_ALL_CALLEE_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rbx,
-    Xbyak::util::rsi,
-    Xbyak::util::rdi,
-    Xbyak::util::rbp,
-    Xbyak::util::r12,
-    Xbyak::util::r13,
-    Xbyak::util::r14,
-    Xbyak::util::r15,
-    // XMMs
-    Xbyak::util::xmm6,
-    Xbyak::util::xmm7,
-    Xbyak::util::xmm8,
-    Xbyak::util::xmm9,
-    Xbyak::util::xmm10,
-    Xbyak::util::xmm11,
-    Xbyak::util::xmm12,
-    Xbyak::util::xmm13,
-    Xbyak::util::xmm14,
-    Xbyak::util::xmm15,
-});
-constexpr std::size_t ABI_SHADOW_SPACE = 0x20;
-#else
-// System V x86-64 ABI
-const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
-const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rdi;
-const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rsi;
-const Xbyak::Reg ABI_PARAM3 = Xbyak::util::rdx;
-const Xbyak::Reg ABI_PARAM4 = Xbyak::util::rcx;
-const BitSet32 ABI_ALL_CALLER_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rcx,
-    Xbyak::util::rdx,
-    Xbyak::util::rdi,
-    Xbyak::util::rsi,
-    Xbyak::util::r8,
-    Xbyak::util::r9,
-    Xbyak::util::r10,
-    Xbyak::util::r11,
-    // XMMs
-    Xbyak::util::xmm0,
-    Xbyak::util::xmm1,
-    Xbyak::util::xmm2,
-    Xbyak::util::xmm3,
-    Xbyak::util::xmm4,
-    Xbyak::util::xmm5,
-    Xbyak::util::xmm6,
-    Xbyak::util::xmm7,
-    Xbyak::util::xmm8,
-    Xbyak::util::xmm9,
-    Xbyak::util::xmm10,
-    Xbyak::util::xmm11,
-    Xbyak::util::xmm12,
-    Xbyak::util::xmm13,
-    Xbyak::util::xmm14,
-    Xbyak::util::xmm15,
-});
-const BitSet32 ABI_ALL_CALLEE_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rbx,
-    Xbyak::util::rbp,
-    Xbyak::util::r12,
-    Xbyak::util::r13,
-    Xbyak::util::r14,
-    Xbyak::util::r15,
-});
-constexpr std::size_t ABI_SHADOW_SPACE = 0;
-#endif
-inline void ABI_CalculateFrameSize(BitSet32 regs, std::size_t rsp_alignment,
-                                   std::size_t needed_frame_size, s32* out_subtraction,
-                                   s32* out_xmm_offset) {
-    int count = (regs & ABI_ALL_GPRS).Count();
-    rsp_alignment -= count * 8;
-    std::size_t subtraction = 0;
-    int xmm_count = (regs & ABI_ALL_XMMS).Count();
-    if (xmm_count) {
-        // If we have any XMMs to save, we must align the stack here.
-        subtraction = rsp_alignment & 0xF;
-    }
-    subtraction += 0x10 * xmm_count;
-    std::size_t xmm_base_subtraction = subtraction;
-    subtraction += needed_frame_size;
-    subtraction += ABI_SHADOW_SPACE;
-    // Final alignment.
-    rsp_alignment -= subtraction;
-    subtraction += rsp_alignment & 0xF;
-    *out_subtraction = (s32)subtraction;
-    *out_xmm_offset = (s32)(subtraction - xmm_base_subtraction);
-}
-inline std::size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
-                                                   std::size_t rsp_alignment,
-                                                   std::size_t needed_frame_size = 0) {
-    s32 subtraction, xmm_offset;
-    ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
-    for (int reg_index : (regs & ABI_ALL_GPRS)) {
-        code.push(IndexToReg64(reg_index));
-    }
-    if (subtraction != 0) {
-        code.sub(code.rsp, subtraction);
-    }
-    for (int reg_index : (regs & ABI_ALL_XMMS)) {
-        code.movaps(code.xword[code.rsp + xmm_offset], IndexToXmm(reg_index));
-        xmm_offset += 0x10;
-    }
-    return ABI_SHADOW_SPACE;
-}
-inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
-                                           std::size_t rsp_alignment,
-                                           std::size_t needed_frame_size = 0) {
-    s32 subtraction, xmm_offset;
-    ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
-    for (int reg_index : (regs & ABI_ALL_XMMS)) {
-        code.movaps(IndexToXmm(reg_index), code.xword[code.rsp + xmm_offset]);
-        xmm_offset += 0x10;
-    }
-    if (subtraction != 0) {
-        code.add(code.rsp, subtraction);
-    }
-    // GPRs need to be popped in reverse order
-    for (int reg_index = 15; reg_index >= 0; reg_index--) {
-        if (regs[reg_index]) {
-            code.pop(IndexToReg64(reg_index));
-        }
-    }
-}
-} // namespace Common::X64
diff --git a/src/common/x64/xbyak_util.h b/src/common/x64/xbyak_util.h
deleted file mode 100644
index 5cc8a8c76..000000000
--- a/src/common/x64/xbyak_util.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-#pragma once
-#include <type_traits>
-#include <xbyak.h>
-#include "common/x64/xbyak_abi.h"
-namespace Common::X64 {
-// Constants for use with cmpps/cmpss
-enum {
-    CMP_EQ = 0,
-    CMP_LT = 1,
-    CMP_LE = 2,
-    CMP_UNORD = 3,
-    CMP_NEQ = 4,
-    CMP_NLT = 5,
-    CMP_NLE = 6,
-    CMP_ORD = 7,
-};
-inline bool IsWithin2G(uintptr_t ref, uintptr_t target) {
-    u64 distance = target - (ref + 5);
-    return !(distance >= 0x8000'0000ULL && distance <= ~0x8000'0000ULL);
-}
-inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
-    return IsWithin2G(reinterpret_cast<uintptr_t>(code.getCurr()), target);
-}
-template <typename T>
-inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
-    static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
-    std::size_t addr = reinterpret_cast<std::size_t>(f);
-    if (IsWithin2G(code, addr)) {
-        code.call(f);
-    } else {
-        // ABI_RETURN is a safe temp register to use before a call
-        code.mov(ABI_RETURN, addr);
-        code.call(ABI_RETURN);
-    }
-}
-} // namespace Common::X64
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index a355eaca6..e1f21a764 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -12,6 +12,8 @@ add_library(core STATIC
    core_timing.h
    core_timing_util.cpp
    core_timing_util.h
+    cpu_core_manager.cpp
+    cpu_core_manager.h
    crypto/aes_util.cpp
    crypto/aes_util.h
    crypto/encryption_layer.cpp
@@ -156,6 +158,8 @@ add_library(core STATIC
    hle/service/am/applets/applets.h
    hle/service/am/applets/software_keyboard.cpp
    hle/service/am/applets/software_keyboard.h
+    hle/service/am/applets/stub_applet.cpp
+    hle/service/am/applets/stub_applet.h
    hle/service/am/idle.cpp
    hle/service/am/idle.h
    hle/service/am/omm.cpp
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 6c72fdf4a..795fabc65 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -14,6 +14,7 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
+#include "core/cpu_core_manager.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
@@ -28,7 +29,6 @@
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
-#include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "frontend/applets/software_keyboard.h"
 #include "video_core/debug_utils/debug_utils.h"
@@ -71,64 +71,22 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
    return vfs->OpenFile(path, FileSys::Mode::Read);
 }
-/// Runs a CPU core while the system is powered on
-void RunCpuCore(Cpu& cpu_state) {
-    while (Core::System::GetInstance().IsPoweredOn()) {
-        cpu_state.RunLoop(true);
-    }
-}
 } // Anonymous namespace
 struct System::Impl {
    Cpu& CurrentCpuCore() {
-        if (Settings::values.use_multi_core) {
+        return cpu_core_manager.GetCurrentCore();
-            const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-            ASSERT(search != thread_to_cpu.end());
-            ASSERT(search->second);
-            return *search->second;
-        }
-        // Otherwise, use single-threaded mode active_core variable
-        return *cpu_cores[active_core];
    }
    ResultStatus RunLoop(bool tight_loop) {
        status = ResultStatus::Success;
-        // Update thread_to_cpu in case Core 0 is run from a different host thread
+        cpu_core_manager.RunLoop(tight_loop);
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::HandlePacket();
-            // If the loop is halted and we want to step, use a tiny (1) number of instructions to
-            // execute. Otherwise, get out of the loop function.
-            if (GDBStub::GetCpuHaltFlag()) {
-                if (GDBStub::GetCpuStepFlag()) {
-                    tight_loop = false;
-                } else {
-                    return ResultStatus::Success;
-                }
-            }
-        }
-        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-            cpu_cores[active_core]->RunLoop(tight_loop);
-            if (Settings::values.use_multi_core) {
-                // Cores 1-3 are run on other threads in this mode
-                break;
-            }
-        }
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::SetCpuStepFlag(false);
-        }
        return status;
    }
-    ResultStatus Init(Frontend::EmuWindow& emu_window) {
+    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
        LOG_DEBUG(HW_Memory, "initialized OK");
        CoreTiming::Init();
@@ -145,12 +103,6 @@ struct System::Impl {
        auto main_process = Kernel::Process::Create(kernel, "main");
        kernel.MakeCurrentProcess(main_process.get());
-        cpu_barrier = std::make_unique<CpuBarrier>();
-        cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
-        for (std::size_t index = 0; index < cpu_cores.size(); ++index) {
-            cpu_cores[index] = std::make_unique<Cpu>(*cpu_exclusive_monitor, *cpu_barrier, index);
-        }
        telemetry_session = std::make_unique<Core::TelemetrySession>();
        service_manager = std::make_shared<Service::SM::ServiceManager>();
@@ -164,17 +116,8 @@ struct System::Impl {
        gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
-        // Create threads for CPU cores 1-3, and build thread_to_cpu map
+        cpu_core_manager.Initialize(system);
-        // CPU core 0 is run on the main thread
+        is_powered_on = true;
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
-        if (Settings::values.use_multi_core) {
-            for (std::size_t index = 0; index < cpu_core_threads.size(); ++index) {
-                cpu_core_threads[index] =
-                    std::make_unique<std::thread>(RunCpuCore, std::ref(*cpu_cores[index + 1]));
-                thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1].get();
-            }
-        }
        LOG_DEBUG(Core, "Initialized OK");
        // Reset counters and set time origin to current frame
@@ -184,7 +127,8 @@ struct System::Impl {
        return ResultStatus::Success;
    }
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
+    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
+                      const std::string& filepath) {
        app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
        if (!app_loader) {
@@ -201,7 +145,7 @@ struct System::Impl {
            return ResultStatus::ErrorSystemMode;
        }
-        ResultStatus init_result{Init(emu_window)};
+        ResultStatus init_result{Init(system, emu_window)};
        if (init_result != ResultStatus::Success) {
            LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                         static_cast<int>(init_result));
@@ -231,6 +175,8 @@ struct System::Impl {
        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
                             perf_results.frametime * 1000.0);
+        is_powered_on = false;
        // Shutdown emulation session
        renderer.reset();
        GDBStub::Shutdown();
@@ -240,19 +186,7 @@ struct System::Impl {
        gpu_core.reset();
        // Close all CPU/threading state
-        cpu_barrier->NotifyEnd();
+        cpu_core_manager.Shutdown();
-        if (Settings::values.use_multi_core) {
-            for (auto& thread : cpu_core_threads) {
-                thread->join();
-                thread.reset();
-            }
-        }
-        thread_to_cpu.clear();
-        for (auto& cpu_core : cpu_cores) {
-            cpu_core.reset();
-        }
-        cpu_exclusive_monitor.reset();
-        cpu_barrier.reset();
        // Shutdown kernel and core timing
        kernel.Shutdown();
@@ -289,11 +223,8 @@ struct System::Impl {
    std::unique_ptr<VideoCore::RendererBase> renderer;
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::shared_ptr<Tegra::DebugContext> debug_context;
-    std::unique_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
+    CpuCoreManager cpu_core_manager;
-    std::unique_ptr<CpuBarrier> cpu_barrier;
+    bool is_powered_on = false;
-    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
-    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
-    std::size_t active_core{}; ///< Active core, only used in single thread mode
    /// Frontend applets
    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
@@ -307,9 +238,6 @@ struct System::Impl {
    ResultStatus status = ResultStatus::Success;
    std::string status_details = "";
-    /// Map of guest threads to CPU cores
-    std::map<std::thread::id, Cpu*> thread_to_cpu;
    Core::PerfStats perf_stats;
    Core::FrameLimiter frame_limiter;
 };
@@ -334,17 +262,15 @@ System::ResultStatus System::SingleStep() {
 }
 void System::InvalidateCpuInstructionCaches() {
-    for (auto& cpu : impl->cpu_cores) {
+    impl->cpu_core_manager.InvalidateAllInstructionCaches();
-        cpu->ArmInterface().ClearInstructionCache();
-    }
 }
 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    return impl->Load(emu_window, filepath);
+    return impl->Load(*this, emu_window, filepath);
 }
 bool System::IsPoweredOn() const {
-    return impl->cpu_barrier && impl->cpu_barrier->IsAlive();
+    return impl->is_powered_on;
 }
 void System::PrepareReschedule() {
@@ -408,21 +334,20 @@ const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
 }
 Cpu& System::CpuCore(std::size_t core_index) {
-    ASSERT(core_index < NUM_CPU_CORES);
+    return impl->cpu_core_manager.GetCore(core_index);
-    return *impl->cpu_cores[core_index];
 }
 const Cpu& System::CpuCore(std::size_t core_index) const {
    ASSERT(core_index < NUM_CPU_CORES);
-    return *impl->cpu_cores[core_index];
+    return impl->cpu_core_manager.GetCore(core_index);
 }
 ExclusiveMonitor& System::Monitor() {
-    return *impl->cpu_exclusive_monitor;
+    return impl->cpu_core_manager.GetExclusiveMonitor();
 }
 const ExclusiveMonitor& System::Monitor() const {
-    return *impl->cpu_exclusive_monitor;
+    return impl->cpu_core_manager.GetExclusiveMonitor();
 }
 Tegra::GPU& System::GPU() {
@@ -506,7 +431,7 @@ const Core::Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() cons
 }
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(emu_window);
+    return impl->Init(*this, emu_window);
 }
 void System::Shutdown() {
diff --git a/src/core/cpu_core_manager.cpp b/src/core/cpu_core_manager.cpp
new file mode 100644
index 000000000..769a6fefa
--- /dev/null
+++ b/src/core/cpu_core_manager.cpp
@@ -0,0 +1,142 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include "common/assert.h"
+#include "core/arm/exclusive_monitor.h"
+#include "core/core.h"
+#include "core/core_cpu.h"
+#include "core/cpu_core_manager.h"
+#include "core/gdbstub/gdbstub.h"
+#include "core/settings.h"
+namespace Core {
+namespace {
+void RunCpuCore(const System& system, Cpu& cpu_state) {
+    while (system.IsPoweredOn()) {
+        cpu_state.RunLoop(true);
+    }
+}
+} // Anonymous namespace
+CpuCoreManager::CpuCoreManager() = default;
+CpuCoreManager::~CpuCoreManager() = default;
+void CpuCoreManager::Initialize(System& system) {
+    barrier = std::make_unique<CpuBarrier>();
+    exclusive_monitor = Cpu::MakeExclusiveMonitor(cores.size());
+    for (std::size_t index = 0; index < cores.size(); ++index) {
+        cores[index] = std::make_unique<Cpu>(*exclusive_monitor, *barrier, index);
+    }
+    // Create threads for CPU cores 1-3, and build thread_to_cpu map
+    // CPU core 0 is run on the main thread
+    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
+    if (!Settings::values.use_multi_core) {
+        return;
+    }
+    for (std::size_t index = 0; index < core_threads.size(); ++index) {
+        core_threads[index] = std::make_unique<std::thread>(RunCpuCore, std::cref(system),
+                                                            std::ref(*cores[index + 1]));
+        thread_to_cpu[core_threads[index]->get_id()] = cores[index + 1].get();
+    }
+}
+void CpuCoreManager::Shutdown() {
+    barrier->NotifyEnd();
+    if (Settings::values.use_multi_core) {
+        for (auto& thread : core_threads) {
+            thread->join();
+            thread.reset();
+        }
+    }
+    thread_to_cpu.clear();
+    for (auto& cpu_core : cores) {
+        cpu_core.reset();
+    }
+    exclusive_monitor.reset();
+    barrier.reset();
+}
+Cpu& CpuCoreManager::GetCore(std::size_t index) {
+    return *cores.at(index);
+}
+const Cpu& CpuCoreManager::GetCore(std::size_t index) const {
+    return *cores.at(index);
+}
+ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() {
+    return *exclusive_monitor;
+}
+const ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() const {
+    return *exclusive_monitor;
+}
+Cpu& CpuCoreManager::GetCurrentCore() {
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+    // Otherwise, use single-threaded mode active_core variable
+    return *cores[active_core];
+}
+const Cpu& CpuCoreManager::GetCurrentCore() const {
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+    // Otherwise, use single-threaded mode active_core variable
+    return *cores[active_core];
+}
+void CpuCoreManager::RunLoop(bool tight_loop) {
+    // Update thread_to_cpu in case Core 0 is run from a different host thread
+    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::HandlePacket();
+        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
+        // execute. Otherwise, get out of the loop function.
+        if (GDBStub::GetCpuHaltFlag()) {
+            if (GDBStub::GetCpuStepFlag()) {
+                tight_loop = false;
+            } else {
+                return;
+            }
+        }
+    }
+    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+        cores[active_core]->RunLoop(tight_loop);
+        if (Settings::values.use_multi_core) {
+            // Cores 1-3 are run on other threads in this mode
+            break;
+        }
+    }
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::SetCpuStepFlag(false);
+    }
+}
+void CpuCoreManager::InvalidateAllInstructionCaches() {
+    for (auto& cpu : cores) {
+        cpu->ArmInterface().ClearInstructionCache();
+    }
+}
+} // namespace Core
diff --git a/src/core/cpu_core_manager.h b/src/core/cpu_core_manager.h
new file mode 100644
index 000000000..a4d70ec56
--- /dev/null
+++ b/src/core/cpu_core_manager.h
@@ -0,0 +1,59 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include <array>
+#include <map>
+#include <memory>
+#include <thread>
+namespace Core {
+class Cpu;
+class CpuBarrier;
+class ExclusiveMonitor;
+class System;
+class CpuCoreManager {
+public:
+    CpuCoreManager();
+    CpuCoreManager(const CpuCoreManager&) = delete;
+    CpuCoreManager(CpuCoreManager&&) = delete;
+    ~CpuCoreManager();
+    CpuCoreManager& operator=(const CpuCoreManager&) = delete;
+    CpuCoreManager& operator=(CpuCoreManager&&) = delete;
+    void Initialize(System& system);
+    void Shutdown();
+    Cpu& GetCore(std::size_t index);
+    const Cpu& GetCore(std::size_t index) const;
+    Cpu& GetCurrentCore();
+    const Cpu& GetCurrentCore() const;
+    ExclusiveMonitor& GetExclusiveMonitor();
+    const ExclusiveMonitor& GetExclusiveMonitor() const;
+    void RunLoop(bool tight_loop);
+    void InvalidateAllInstructionCaches();
+private:
+    static constexpr std::size_t NUM_CPU_CORES = 4;
+    std::unique_ptr<ExclusiveMonitor> exclusive_monitor;
+    std::unique_ptr<CpuBarrier> barrier;
+    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cores;
+    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> core_threads;
+    std::size_t active_core{}; ///< Active core, only used in single thread mode
+    /// Map of guest threads to CPU cores
+    std::map<std::thread::id, Cpu*> thread_to_cpu;
+};
+} // namespace Core
diff --git a/src/core/file_sys/card_image.h b/src/core/file_sys/card_image.h
index 25f5914b6..a350496f7 100644
--- a/src/core/file_sys/card_image.h
+++ b/src/core/file_sys/card_image.h
@@ -32,7 +32,18 @@ enum class GamecardSize : u8 {
 };
 struct GamecardInfo {
-    std::array<u8, 0x70> data;
+    u64_le firmware_version;
+    u32_le access_control_flags;
+    u32_le read_wait_time1;
+    u32_le read_wait_time2;
+    u32_le write_wait_time1;
+    u32_le write_wait_time2;
+    u32_le firmware_mode;
+    u32_le cup_version;
+    std::array<u8, 4> reserved1;
+    u64_le update_partition_hash;
+    u64_le cup_id;
+    std::array<u8, 0x38> reserved2;
 };
 static_assert(sizeof(GamecardInfo) == 0x70, "GamecardInfo has incorrect size.");
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index 8d062eb3e..e8df08724 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -26,6 +26,11 @@ namespace FileSys {
 constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
+constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
+    "main",    "main.npdm", "rtld",    "sdk",     "subsdk0", "subsdk1", "subsdk2",
+    "subsdk3", "subsdk4",   "subsdk5", "subsdk6", "subsdk7", "subsdk8", "subsdk9",
+};
 struct NSOBuildHeader {
    u32_le magic;
    INSERT_PADDING_BYTES(0x3C);
@@ -57,6 +62,15 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    if (exefs == nullptr)
        return exefs;
+    if (Settings::values.dump_exefs) {
+        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
+        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
+        if (dump_dir != nullptr) {
+            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
+            VfsRawCopyD(exefs, exefs_dir);
+        }
+    }
    const auto installed = Service::FileSystem::GetUnionContents();
    // Game Updates
@@ -70,6 +84,30 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
        exefs = update->GetExeFS();
    }
+    // LayeredExeFS
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    if (load_dir != nullptr && load_dir->GetSize() > 0) {
+        auto patch_dirs = load_dir->GetSubdirectories();
+        std::sort(
+            patch_dirs.begin(), patch_dirs.end(),
+            [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
+        std::vector<VirtualDir> layers;
+        layers.reserve(patch_dirs.size() + 1);
+        for (const auto& subdir : patch_dirs) {
+            auto exefs_dir = subdir->GetSubdirectory("exefs");
+            if (exefs_dir != nullptr)
+                layers.push_back(std::move(exefs_dir));
+        }
+        layers.push_back(exefs);
+        auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
+        if (layered != nullptr) {
+            LOG_INFO(Loader, "    ExeFS: LayeredExeFS patches applied successfully");
+            exefs = std::move(layered);
+        }
+    }
    return exefs;
 }
@@ -314,18 +352,25 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
            if (IsDirValidAndNonEmpty(exefs_dir)) {
                bool ips = false;
                bool ipswitch = false;
+                bool layeredfs = false;
                for (const auto& file : exefs_dir->GetFiles()) {
-                    if (file->GetExtension() == "ips")
+                    if (file->GetExtension() == "ips") {
                        ips = true;
-                    else if (file->GetExtension() == "pchtxt")
+                    } else if (file->GetExtension() == "pchtxt") {
                        ipswitch = true;
+                    } else if (std::find(EXEFS_FILE_NAMES.begin(), EXEFS_FILE_NAMES.end(),
+                                         file->GetName()) != EXEFS_FILE_NAMES.end()) {
+                        layeredfs = true;
+                    }
                }
                if (ips)
                    AppendCommaIfNotEmpty(types, "IPS");
                if (ipswitch)
                    AppendCommaIfNotEmpty(types, "IPSwitch");
+                if (layeredfs)
+                    AppendCommaIfNotEmpty(types, "LayeredExeFS");
            }
            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
                AppendCommaIfNotEmpty(types, "LayeredFS");
diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp
index bdcc889e0..687dea409 100644
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -71,10 +71,6 @@ constexpr u32 PSTATE_REGISTER = 33;
 constexpr u32 UC_ARM64_REG_Q0 = 34;
 constexpr u32 FPCR_REGISTER = 66;
-// TODO/WiP - Used while working on support for FPU
-constexpr u32 TODO_DUMMY_REG_997 = 997;
-constexpr u32 TODO_DUMMY_REG_998 = 998;
 // For sample XML files see the GDB source /gdb/features
 // GDB also wants the l character at the start
 // This XML defines what the registers are for this specific ARM device
@@ -260,6 +256,36 @@ static void RegWrite(std::size_t id, u64 val, Kernel::Thread* thread = nullptr)
    }
 }
+static u128 FpuRead(std::size_t id, Kernel::Thread* thread = nullptr) {
+    if (!thread) {
+        return u128{0};
+    }
+    auto& thread_context = thread->GetContext();
+    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
+        return thread_context.vector_registers[id - UC_ARM64_REG_Q0];
+    } else if (id == FPCR_REGISTER) {
+        return u128{thread_context.fpcr, 0};
+    } else {
+        return u128{0};
+    }
+}
+static void FpuWrite(std::size_t id, u128 val, Kernel::Thread* thread = nullptr) {
+    if (!thread) {
+        return;
+    }
+    auto& thread_context = thread->GetContext();
+    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
+        thread_context.vector_registers[id - UC_ARM64_REG_Q0] = val;
+    } else if (id == FPCR_REGISTER) {
+        thread_context.fpcr = val[0];
+    }
+}
 /**
 * Turns hex string character into the equivalent byte.
 *
@@ -409,6 +435,27 @@ static u64 GdbHexToLong(const u8* src) {
    return output;
 }
+/**
+ * Convert a gdb-formatted hex string into a u128.
+ *
+ * @param src Pointer to hex string.
+ */
+static u128 GdbHexToU128(const u8* src) {
+    u128 output;
+    for (int i = 0; i < 16; i += 2) {
+        output[0] = (output[0] << 4) | HexCharToValue(src[15 - i - 1]);
+        output[0] = (output[0] << 4) | HexCharToValue(src[15 - i]);
+    }
+    for (int i = 0; i < 16; i += 2) {
+        output[1] = (output[1] << 4) | HexCharToValue(src[16 + 15 - i - 1]);
+        output[1] = (output[1] << 4) | HexCharToValue(src[16 + 15 - i]);
+    }
+    return output;
+}
 /// Read a byte from the gdb client.
 static u8 ReadByte() {
    u8 c;
@@ -599,8 +646,7 @@ static void HandleQuery() {
        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
            for (const auto& thread : threads) {
-                val += fmt::format("{:x}", thread->GetThreadID());
+                val += fmt::format("{:x},", thread->GetThreadID());
-                val += ",";
            }
        }
        val.pop_back();
@@ -791,11 +837,15 @@ static void ReadRegister() {
    } else if (id == PSTATE_REGISTER) {
        IntToGdbHex(reply, static_cast<u32>(RegRead(id, current_thread)));
    } else if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        LongToGdbHex(reply, RegRead(id, current_thread));
+        u128 r = FpuRead(id, current_thread);
+        LongToGdbHex(reply, r[0]);
+        LongToGdbHex(reply + 16, r[1]);
    } else if (id == FPCR_REGISTER) {
-        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_998, current_thread));
+        u128 r = FpuRead(id, current_thread);
-    } else {
+        IntToGdbHex(reply, static_cast<u32>(r[0]));
-        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_997, current_thread));
+    } else if (id == FPCR_REGISTER + 1) {
+        u128 r = FpuRead(id, current_thread);
+        IntToGdbHex(reply, static_cast<u32>(r[0] >> 32));
    }
    SendReply(reinterpret_cast<char*>(reply));
@@ -822,13 +872,18 @@ static void ReadRegisters() {
    bufptr += 8;
-    for (u32 reg = UC_ARM64_REG_Q0; reg <= UC_ARM64_REG_Q0 + 31; reg++) {
+    u128 r;
-        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
+    for (u32 reg = UC_ARM64_REG_Q0; reg < FPCR_REGISTER; reg++) {
+        r = FpuRead(reg, current_thread);
+        LongToGdbHex(bufptr + reg * 32, r[0]);
+        LongToGdbHex(bufptr + reg * 32 + 16, r[1]);
    }
    bufptr += 32 * 32;
-    LongToGdbHex(bufptr, RegRead(TODO_DUMMY_REG_998, current_thread));
+    r = FpuRead(FPCR_REGISTER, current_thread);
+    IntToGdbHex(bufptr, static_cast<u32>(r[0]));
    bufptr += 8;
@@ -853,14 +908,12 @@ static void WriteRegister() {
    } else if (id == PSTATE_REGISTER) {
        RegWrite(id, GdbHexToInt(buffer_ptr), current_thread);
    } else if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
-        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
+        FpuWrite(id, GdbHexToU128(buffer_ptr), current_thread);
    } else if (id == FPCR_REGISTER) {
-        RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr), current_thread);
+    } else if (id == FPCR_REGISTER + 1) {
-    } else {
-        RegWrite(TODO_DUMMY_REG_997, GdbHexToLong(buffer_ptr), current_thread);
    }
-    // Update Unicorn context skipping scheduler, no running threads at this point
+    // Update ARM context, skipping scheduler - no running threads at this point
    Core::System::GetInstance()
        .ArmInterface(current_core)
        .LoadContext(current_thread->GetContext());
@@ -885,13 +938,13 @@ static void WriteRegisters() {
        } else if (reg >= UC_ARM64_REG_Q0 && reg < FPCR_REGISTER) {
            RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
        } else if (reg == FPCR_REGISTER) {
-            RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr + i * 16), current_thread);
+            RegWrite(FPCR_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
-        } else {
+        } else if (reg == FPCR_REGISTER + 1) {
-            UNIMPLEMENTED();
+            RegWrite(FPCR_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
        }
    }
-    // Update Unicorn context skipping scheduler, no running threads at this point
+    // Update ARM context, skipping scheduler - no running threads at this point
    Core::System::GetInstance()
        .ArmInterface(current_core)
        .LoadContext(current_thread->GetContext());
@@ -917,12 +970,6 @@ static void ReadMemory() {
        SendReply("E01");
    }
-    const auto& vm_manager = Core::CurrentProcess()->VMManager();
-    if (addr < vm_manager.GetCodeRegionBaseAddress() ||
-        addr >= vm_manager.GetMapRegionEndAddress()) {
-        return SendReply("E00");
-    }
    if (!Memory::IsValidVirtualAddress(addr)) {
        return SendReply("E00");
    }
@@ -967,7 +1014,7 @@ void Break(bool is_memory_break) {
 static void Step() {
    if (command_length > 1) {
        RegWrite(PC_REGISTER, GdbHexToLong(command_buffer + 1), current_thread);
-        // Update Unicorn context skipping scheduler, no running threads at this point
+        // Update ARM context, skipping scheduler - no running threads at this point
        Core::System::GetInstance()
            .ArmInterface(current_core)
            .LoadContext(current_thread->GetContext());
@@ -1010,7 +1057,7 @@ static bool CommitBreakpoint(BreakpointType type, VAddr addr, u64 len) {
    breakpoint.addr = addr;
    breakpoint.len = len;
    Memory::ReadBlock(addr, breakpoint.inst.data(), breakpoint.inst.size());
-    static constexpr std::array<u8, 4> btrap{{0x00, 0x7d, 0x20, 0xd4}};
+    static constexpr std::array<u8, 4> btrap{0x00, 0x7d, 0x20, 0xd4};
    Memory::WriteBlock(addr, btrap.data(), btrap.size());
    Core::System::GetInstance().InvalidateCpuInstructionCaches();
    p.insert({addr, breakpoint});
@@ -1321,13 +1368,15 @@ void SetCpuStepFlag(bool is_step) {
 }
 void SendTrap(Kernel::Thread* thread, int trap) {
-    if (send_trap) {
+    if (!send_trap) {
-        if (!halt_loop || current_thread == thread) {
+        return;
-            current_thread = thread;
-            SendSignal(thread, trap);
-        }
-        halt_loop = true;
-        send_trap = false;
    }
+    if (!halt_loop || current_thread == thread) {
+        current_thread = thread;
+        SendSignal(thread, trap);
+    }
+    halt_loop = true;
+    send_trap = false;
 }
 }; // namespace GDBStub
diff --git a/src/core/hle/kernel/handle_table.cpp b/src/core/hle/kernel/handle_table.cpp
index 5ee5c05e3..1bf79b692 100644
--- a/src/core/hle/kernel/handle_table.cpp
+++ b/src/core/hle/kernel/handle_table.cpp
@@ -12,12 +12,23 @@
 #include "core/hle/kernel/thread.h"
 namespace Kernel {
+namespace {
+constexpr u16 GetSlot(Handle handle) {
+    return handle >> 15;
+}
+constexpr u16 GetGeneration(Handle handle) {
+    return handle & 0x7FFF;
+}
+} // Anonymous namespace
 HandleTable::HandleTable() {
    next_generation = 1;
    Clear();
 }
+HandleTable::~HandleTable() = default;
 ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
    DEBUG_ASSERT(obj != nullptr);
diff --git a/src/core/hle/kernel/handle_table.h b/src/core/hle/kernel/handle_table.h
index 9e2f33e8a..e3f3e3fb8 100644
--- a/src/core/hle/kernel/handle_table.h
+++ b/src/core/hle/kernel/handle_table.h
@@ -43,6 +43,7 @@ enum KernelHandle : Handle {
 class HandleTable final : NonCopyable {
 public:
    HandleTable();
+    ~HandleTable();
    /**
     * Allocates a handle for the given object.
@@ -89,18 +90,8 @@ public:
    void Clear();
 private:
-    /**
+    /// This is the maximum limit of handles allowed per process in Horizon
-     * This is the maximum limit of handles allowed per process in CTR-OS. It can be further
+    static constexpr std::size_t MAX_COUNT = 1024;
-     * reduced by ExHeader values, but this is not emulated here.
-     */
-    static const std::size_t MAX_COUNT = 4096;
-    static u16 GetSlot(Handle handle) {
-        return handle >> 15;
-    }
-    static u16 GetGeneration(Handle handle) {
-        return handle & 0x7FFF;
-    }
    /// Stores the Object referenced by the handle or null if the slot is empty.
    std::array<SharedPtr<Object>, MAX_COUNT> objects;
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 1412257a0..7ca538401 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <memory>
+#include <random>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index 230e395ff..ada845c7f 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -8,7 +8,6 @@
 #include <bitset>
 #include <cstddef>
 #include <memory>
-#include <random>
 #include <string>
 #include <vector>
 #include <boost/container/static_vector.hpp>
diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp
index a016a86b6..0494581f5 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -61,7 +61,7 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, SharedPtr<Proce
 }
 SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
-    KernelCore& kernel, std::shared_ptr<std::vector<u8>> heap_block, u32 offset, u32 size,
+    KernelCore& kernel, std::shared_ptr<std::vector<u8>> heap_block, std::size_t offset, u64 size,
    MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
@@ -78,10 +78,10 @@ SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
    return shared_memory;
 }
-ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermission permissions,
+ResultCode SharedMemory::Map(Process& target_process, VAddr address, MemoryPermission permissions,
                             MemoryPermission other_permissions) {
    const MemoryPermission own_other_permissions =
-        target_process == owner_process ? this->permissions : this->other_permissions;
+        &target_process == owner_process ? this->permissions : this->other_permissions;
    // Automatically allocated memory blocks can only be mapped with other_permissions = DontCare
    if (base_address == 0 && other_permissions != MemoryPermission::DontCare) {
@@ -106,7 +106,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
    VAddr target_address = address;
    // Map the memory block into the target process
-    auto result = target_process->VMManager().MapMemoryBlock(
+    auto result = target_process.VMManager().MapMemoryBlock(
        target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
    if (result.Failed()) {
        LOG_ERROR(
@@ -116,14 +116,14 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
        return result.Code();
    }
-    return target_process->VMManager().ReprotectRange(target_address, size,
+    return target_process.VMManager().ReprotectRange(target_address, size,
-                                                      ConvertPermissions(permissions));
+                                                     ConvertPermissions(permissions));
 }
-ResultCode SharedMemory::Unmap(Process* target_process, VAddr address) {
+ResultCode SharedMemory::Unmap(Process& target_process, VAddr address) {
    // TODO(Subv): Verify what happens if the application tries to unmap an address that is not
    // mapped to a SharedMemory.
-    return target_process->VMManager().UnmapRange(address, size);
+    return target_process.VMManager().UnmapRange(address, size);
 }
 VMAPermission SharedMemory::ConvertPermissions(MemoryPermission permission) {
@@ -132,7 +132,11 @@ VMAPermission SharedMemory::ConvertPermissions(MemoryPermission permission) {
    return static_cast<VMAPermission>(masked_permissions);
 }
-u8* SharedMemory::GetPointer(u32 offset) {
+u8* SharedMemory::GetPointer(std::size_t offset) {
+    return backing_block->data() + backing_block_offset + offset;
+}
+const u8* SharedMemory::GetPointer(std::size_t offset) const {
    return backing_block->data() + backing_block_offset + offset;
 }
diff --git a/src/core/hle/kernel/shared_memory.h b/src/core/hle/kernel/shared_memory.h
index 2c06bb7ce..0b48db699 100644
--- a/src/core/hle/kernel/shared_memory.h
+++ b/src/core/hle/kernel/shared_memory.h
@@ -64,7 +64,7 @@ public:
     */
    static SharedPtr<SharedMemory> CreateForApplet(KernelCore& kernel,
                                                   std::shared_ptr<std::vector<u8>> heap_block,
-                                                   u32 offset, u32 size,
+                                                   std::size_t offset, u64 size,
                                                   MemoryPermission permissions,
                                                   MemoryPermission other_permissions,
                                                   std::string name = "Unknown Applet");
@@ -81,6 +81,11 @@ public:
        return HANDLE_TYPE;
    }
+    /// Gets the size of the underlying memory block in bytes.
+    u64 GetSize() const {
+        return size;
+    }
    /**
     * Converts the specified MemoryPermission into the equivalent VMAPermission.
     * @param permission The MemoryPermission to convert.
@@ -94,44 +99,51 @@ public:
     * @param permissions Memory block map permissions (specified by SVC field)
     * @param other_permissions Memory block map other permissions (specified by SVC field)
     */
-    ResultCode Map(Process* target_process, VAddr address, MemoryPermission permissions,
+    ResultCode Map(Process& target_process, VAddr address, MemoryPermission permissions,
                   MemoryPermission other_permissions);
    /**
     * Unmaps a shared memory block from the specified address in system memory
-     * @param target_process Process from which to umap the memory block.
+     * @param target_process Process from which to unmap the memory block.
     * @param address Address in system memory where the shared memory block is mapped
     * @return Result code of the unmap operation
     */
-    ResultCode Unmap(Process* target_process, VAddr address);
+    ResultCode Unmap(Process& target_process, VAddr address);
    /**
     * Gets a pointer to the shared memory block
     * @param offset Offset from the start of the shared memory block to get pointer
-     * @return Pointer to the shared memory block from the specified offset
+     * @return A pointer to the shared memory block from the specified offset
     */
-    u8* GetPointer(u32 offset = 0);
+    u8* GetPointer(std::size_t offset = 0);
+    /**
+     * Gets a constant pointer to the shared memory block
+     * @param offset Offset from the start of the shared memory block to get pointer
+     * @return A constant pointer to the shared memory block from the specified offset
+     */
+    const u8* GetPointer(std::size_t offset = 0) const;
+private:
+    explicit SharedMemory(KernelCore& kernel);
+    ~SharedMemory() override;
-    /// Process that created this shared memory block.
-    SharedPtr<Process> owner_process;
-    /// Address of shared memory block in the owner process if specified.
-    VAddr base_address;
    /// Backing memory for this shared memory block.
    std::shared_ptr<std::vector<u8>> backing_block;
    /// Offset into the backing block for this shared memory.
-    std::size_t backing_block_offset;
+    std::size_t backing_block_offset = 0;
    /// Size of the memory block. Page-aligned.
-    u64 size;
+    u64 size = 0;
    /// Permission restrictions applied to the process which created the block.
-    MemoryPermission permissions;
+    MemoryPermission permissions{};
    /// Permission restrictions applied to other processes mapping the block.
-    MemoryPermission other_permissions;
+    MemoryPermission other_permissions{};
+    /// Process that created this shared memory block.
+    SharedPtr<Process> owner_process;
+    /// Address of shared memory block in the owner process if specified.
+    VAddr base_address = 0;
    /// Name of shared memory object.
    std::string name;
-private:
-    explicit SharedMemory(KernelCore& kernel);
-    ~SharedMemory() override;
 };
 } // namespace Kernel
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 51c367de7..b8b6b4d49 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -789,7 +789,7 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
        return ERR_INVALID_MEMORY_RANGE;
    }
-    return shared_memory->Map(current_process, addr, permissions_type, MemoryPermission::DontCare);
+    return shared_memory->Map(*current_process, addr, permissions_type, MemoryPermission::DontCare);
 }
 static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
@@ -819,7 +819,7 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
        return ERR_INVALID_MEMORY_RANGE;
    }
-    return shared_memory->Unmap(current_process, addr);
+    return shared_memory->Unmap(*current_process, addr);
 }
 /// Query process memory
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index fd14af1e7..4f17b52f9 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -6,8 +6,6 @@
 #include <cinttypes>
 #include <cstring>
 #include <stack>
-#include "applets/applets.h"
-#include "applets/software_keyboard.h"
 #include "audio_core/audio_renderer.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
@@ -18,6 +16,9 @@
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
+#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/am/applets/software_keyboard.h"
+#include "core/hle/service/am/applets/stub_applet.h"
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
@@ -482,11 +483,15 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&
    rb.Push(RESULT_SUCCESS);
    if (Settings::values.use_docked_mode) {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
+                static_cast<u32>(Settings::values.resolution_factor));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
+                static_cast<u32>(Settings::values.resolution_factor));
    } else {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
+                static_cast<u32>(Settings::values.resolution_factor));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
+                static_cast<u32>(Settings::values.resolution_factor));
    }
    LOG_DEBUG(Service_AM, "called");
@@ -532,8 +537,7 @@ void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
 public:
    explicit ILibraryAppletAccessor(std::shared_ptr<Applets::Applet> applet)
-        : ServiceFramework("ILibraryAppletAccessor"), applet(std::move(applet)),
+        : ServiceFramework("ILibraryAppletAccessor"), applet(std::move(applet)) {
-          broker(std::make_shared<Applets::AppletDataBroker>()) {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &ILibraryAppletAccessor::GetAppletStateChangedEvent, "GetAppletStateChangedEvent"},
@@ -562,7 +566,7 @@ public:
 private:
    void GetAppletStateChangedEvent(Kernel::HLERequestContext& ctx) {
-        const auto event = broker->GetStateChangedEvent();
+        const auto event = applet->GetBroker().GetStateChangedEvent();
        event->Signal();
        IPC::ResponseBuilder rb{ctx, 2, 1};
@@ -590,7 +594,7 @@ private:
    void Start(Kernel::HLERequestContext& ctx) {
        ASSERT(applet != nullptr);
-        applet->Initialize(broker);
+        applet->Initialize();
        applet->Execute();
        IPC::ResponseBuilder rb{ctx, 2};
@@ -601,7 +605,7 @@ private:
    void PushInData(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
-        broker->PushNormalDataFromGame(*rp.PopIpcInterface<IStorage>());
+        applet->GetBroker().PushNormalDataFromGame(*rp.PopIpcInterface<IStorage>());
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
@@ -612,7 +616,7 @@ private:
    void PopOutData(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        const auto storage = broker->PopNormalDataToGame();
+        const auto storage = applet->GetBroker().PopNormalDataToGame();
        if (storage == nullptr) {
            rb.Push(ERR_NO_DATA_IN_CHANNEL);
            return;
@@ -626,7 +630,7 @@ private:
    void PushInteractiveInData(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
-        broker->PushInteractiveDataFromGame(*rp.PopIpcInterface<IStorage>());
+        applet->GetBroker().PushInteractiveDataFromGame(*rp.PopIpcInterface<IStorage>());
        ASSERT(applet->IsInitialized());
        applet->ExecuteInteractive();
@@ -641,7 +645,7 @@ private:
    void PopInteractiveOutData(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        const auto storage = broker->PopInteractiveDataToGame();
+        const auto storage = applet->GetBroker().PopInteractiveDataToGame();
        if (storage == nullptr) {
            rb.Push(ERR_NO_DATA_IN_CHANNEL);
            return;
@@ -656,7 +660,7 @@ private:
    void GetPopOutDataEvent(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(broker->GetNormalDataEvent());
+        rb.PushCopyObjects(applet->GetBroker().GetNormalDataEvent());
        LOG_DEBUG(Service_AM, "called");
    }
@@ -664,13 +668,12 @@ private:
    void GetPopInteractiveOutDataEvent(Kernel::HLERequestContext& ctx) {
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(broker->GetInteractiveDataEvent());
+        rb.PushCopyObjects(applet->GetBroker().GetInteractiveDataEvent());
        LOG_DEBUG(Service_AM, "called");
    }
    std::shared_ptr<Applets::Applet> applet;
-    std::shared_ptr<Applets::AppletDataBroker> broker;
 };
 void IStorage::Open(Kernel::HLERequestContext& ctx) {
@@ -763,8 +766,9 @@ static std::shared_ptr<Applets::Applet> GetAppletFromId(AppletId id) {
    case AppletId::SoftwareKeyboard:
        return std::make_shared<Applets::SoftwareKeyboard>();
    default:
-        UNREACHABLE_MSG("Unimplemented AppletId [{:08X}]!", static_cast<u32>(id));
+        LOG_ERROR(Service_AM, "Unimplemented AppletId [{:08X}]! -- Falling back to stub!",
-        return nullptr;
+                  static_cast<u32>(id));
+        return std::make_shared<Applets::StubApplet>();
    }
 }
@@ -820,8 +824,8 @@ void ILibraryAppletCreator::CreateTransferMemoryStorage(Kernel::HLERequestContex
        return;
    }
-    const auto mem_begin = shared_mem->backing_block->begin() + shared_mem->backing_block_offset;
+    const u8* mem_begin = shared_mem->GetPointer();
-    const auto mem_end = mem_begin + shared_mem->size;
+    const u8* mem_end = mem_begin + shared_mem->GetSize();
    std::vector<u8> memory{mem_begin, mem_end};
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
diff --git a/src/core/hle/service/am/applets/applets.cpp b/src/core/hle/service/am/applets/applets.cpp
index 8adb81823..becbadd06 100644
--- a/src/core/hle/service/am/applets/applets.cpp
+++ b/src/core/hle/service/am/applets/applets.cpp
@@ -98,10 +98,8 @@ Applet::Applet() = default;
 Applet::~Applet() = default;
-void Applet::Initialize(std::shared_ptr<AppletDataBroker> broker_) {
+void Applet::Initialize() {
-    broker = std::move(broker_);
+    const auto common = broker.PopNormalDataToApplet();
-    const auto common = broker->PopNormalDataToApplet();
    ASSERT(common != nullptr);
    const auto common_data = common->GetData();
diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h
index 136445649..f65ea119c 100644
--- a/src/core/hle/service/am/applets/applets.h
+++ b/src/core/hle/service/am/applets/applets.h
@@ -4,14 +4,17 @@
 #pragma once
-#include <functional>
 #include <memory>
 #include <queue>
 #include "common/swap.h"
-#include "core/hle/kernel/event.h"
+#include "core/hle/kernel/kernel.h"
 union ResultCode;
+namespace Kernel {
+class Event;
+}
 namespace Service::AM {
 class IStorage;
@@ -43,19 +46,26 @@ public:
 private:
    // Queues are named from applet's perspective
-    std::queue<std::unique_ptr<IStorage>>
-        in_channel; // PopNormalDataToApplet and PushNormalDataFromGame
+    // PopNormalDataToApplet and PushNormalDataFromGame
-    std::queue<std::unique_ptr<IStorage>>
+    std::queue<std::unique_ptr<IStorage>> in_channel;
-        out_channel; // PopNormalDataToGame and PushNormalDataFromApplet
-    std::queue<std::unique_ptr<IStorage>>
+    // PopNormalDataToGame and PushNormalDataFromApplet
-        in_interactive_channel; // PopInteractiveDataToApplet and PushInteractiveDataFromGame
+    std::queue<std::unique_ptr<IStorage>> out_channel;
-    std::queue<std::unique_ptr<IStorage>>
-        out_interactive_channel; // PopInteractiveDataToGame and PushInteractiveDataFromApplet
+    // PopInteractiveDataToApplet and PushInteractiveDataFromGame
+    std::queue<std::unique_ptr<IStorage>> in_interactive_channel;
+    // PopInteractiveDataToGame and PushInteractiveDataFromApplet
+    std::queue<std::unique_ptr<IStorage>> out_interactive_channel;
    Kernel::SharedPtr<Kernel::Event> state_changed_event;
-    Kernel::SharedPtr<Kernel::Event> pop_out_data_event; // Signaled on PushNormalDataFromApplet
-    Kernel::SharedPtr<Kernel::Event>
+    // Signaled on PushNormalDataFromApplet
-        pop_interactive_out_data_event; // Signaled on PushInteractiveDataFromApplet
+    Kernel::SharedPtr<Kernel::Event> pop_out_data_event;
+    // Signaled on PushInteractiveDataFromApplet
+    Kernel::SharedPtr<Kernel::Event> pop_interactive_out_data_event;
 };
 class Applet {
@@ -63,7 +73,7 @@ public:
    Applet();
    virtual ~Applet();
-    virtual void Initialize(std::shared_ptr<AppletDataBroker> broker);
+    virtual void Initialize();
    virtual bool TransactionComplete() const = 0;
    virtual ResultCode GetStatus() const = 0;
@@ -74,6 +84,14 @@ public:
        return initialized;
    }
+    AppletDataBroker& GetBroker() {
+        return broker;
+    }
+    const AppletDataBroker& GetBroker() const {
+        return broker;
+    }
 protected:
    struct CommonArguments {
        u32_le arguments_version;
@@ -85,8 +103,8 @@ protected:
    };
    static_assert(sizeof(CommonArguments) == 0x20, "CommonArguments has incorrect size.");
-    CommonArguments common_args;
+    CommonArguments common_args{};
-    std::shared_ptr<AppletDataBroker> broker;
+    AppletDataBroker broker;
    bool initialized = false;
 };
diff --git a/src/core/hle/service/am/applets/software_keyboard.cpp b/src/core/hle/service/am/applets/software_keyboard.cpp
index c4b76a515..981bdec51 100644
--- a/src/core/hle/service/am/applets/software_keyboard.cpp
+++ b/src/core/hle/service/am/applets/software_keyboard.cpp
@@ -42,21 +42,21 @@ SoftwareKeyboard::SoftwareKeyboard() = default;
 SoftwareKeyboard::~SoftwareKeyboard() = default;
-void SoftwareKeyboard::Initialize(std::shared_ptr<AppletDataBroker> broker_) {
+void SoftwareKeyboard::Initialize() {
    complete = false;
    initial_text.clear();
    final_data.clear();
-    Applet::Initialize(std::move(broker_));
+    Applet::Initialize();
-    const auto keyboard_config_storage = broker->PopNormalDataToApplet();
+    const auto keyboard_config_storage = broker.PopNormalDataToApplet();
    ASSERT(keyboard_config_storage != nullptr);
    const auto& keyboard_config = keyboard_config_storage->GetData();
    ASSERT(keyboard_config.size() >= sizeof(KeyboardConfig));
    std::memcpy(&config, keyboard_config.data(), sizeof(KeyboardConfig));
-    const auto work_buffer_storage = broker->PopNormalDataToApplet();
+    const auto work_buffer_storage = broker.PopNormalDataToApplet();
    ASSERT(work_buffer_storage != nullptr);
    const auto& work_buffer = work_buffer_storage->GetData();
@@ -81,7 +81,7 @@ void SoftwareKeyboard::ExecuteInteractive() {
    if (complete)
        return;
-    const auto storage = broker->PopInteractiveDataToApplet();
+    const auto storage = broker.PopInteractiveDataToApplet();
    ASSERT(storage != nullptr);
    const auto data = storage->GetData();
    const auto status = static_cast<bool>(data[0]);
@@ -95,13 +95,13 @@ void SoftwareKeyboard::ExecuteInteractive() {
        std::memcpy(string.data(), data.data() + 4, string.size() * 2);
        frontend.SendTextCheckDialog(
            Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
-            [this] { broker->SignalStateChanged(); });
+            [this] { broker.SignalStateChanged(); });
    }
 }
 void SoftwareKeyboard::Execute() {
    if (complete) {
-        broker->PushNormalDataFromApplet(IStorage{final_data});
+        broker.PushNormalDataFromApplet(IStorage{final_data});
        return;
    }
@@ -145,17 +145,17 @@ void SoftwareKeyboard::WriteText(std::optional<std::u16string> text) {
        final_data = output_main;
        if (complete) {
-            broker->PushNormalDataFromApplet(IStorage{output_main});
+            broker.PushNormalDataFromApplet(IStorage{output_main});
        } else {
-            broker->PushInteractiveDataFromApplet(IStorage{output_sub});
+            broker.PushInteractiveDataFromApplet(IStorage{output_sub});
        }
-        broker->SignalStateChanged();
+        broker.SignalStateChanged();
    } else {
        output_main[0] = 1;
        complete = true;
-        broker->PushNormalDataFromApplet(IStorage{output_main});
+        broker.PushNormalDataFromApplet(IStorage{output_main});
-        broker->SignalStateChanged();
+        broker.SignalStateChanged();
    }
 }
 } // namespace Service::AM::Applets
diff --git a/src/core/hle/service/am/applets/software_keyboard.h b/src/core/hle/service/am/applets/software_keyboard.h
index 16e1fff66..efd5753a1 100644
--- a/src/core/hle/service/am/applets/software_keyboard.h
+++ b/src/core/hle/service/am/applets/software_keyboard.h
@@ -4,7 +4,12 @@
 #pragma once
+#include <array>
+#include <string>
+#include <vector>
 #include "common/common_funcs.h"
+#include "common/swap.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"
@@ -50,7 +55,7 @@ public:
    SoftwareKeyboard();
    ~SoftwareKeyboard() override;
-    void Initialize(std::shared_ptr<AppletDataBroker> broker) override;
+    void Initialize() override;
    bool TransactionComplete() const override;
    ResultCode GetStatus() const override;
diff --git a/src/core/hle/service/am/applets/stub_applet.cpp b/src/core/hle/service/am/applets/stub_applet.cpp
new file mode 100644
index 000000000..ed166b87d
--- /dev/null
+++ b/src/core/hle/service/am/applets/stub_applet.cpp
@@ -0,0 +1,70 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#include <string>
+#include "common/hex_util.h"
+#include "common/logging/log.h"
+#include "core/hle/result.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/stub_applet.h"
+namespace Service::AM::Applets {
+static void LogCurrentStorage(AppletDataBroker& broker, std::string prefix) {
+    std::unique_ptr<IStorage> storage = broker.PopNormalDataToApplet();
+    for (; storage != nullptr; storage = broker.PopNormalDataToApplet()) {
+        const auto data = storage->GetData();
+        LOG_INFO(Service_AM,
+                 "called (STUBBED), during {} recieved normal data with size={:08X}, data={}",
+                 prefix, data.size(), Common::HexVectorToString(data));
+    }
+    storage = broker.PopInteractiveDataToApplet();
+    for (; storage != nullptr; storage = broker.PopInteractiveDataToApplet()) {
+        const auto data = storage->GetData();
+        LOG_INFO(Service_AM,
+                 "called (STUBBED), during {} recieved interactive data with size={:08X}, data={}",
+                 prefix, data.size(), Common::HexVectorToString(data));
+    }
+}
+StubApplet::StubApplet() = default;
+StubApplet::~StubApplet() = default;
+void StubApplet::Initialize() {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    Applet::Initialize();
+    LogCurrentStorage(broker, "Initialize");
+}
+bool StubApplet::TransactionComplete() const {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    return true;
+}
+ResultCode StubApplet::GetStatus() const {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    return RESULT_SUCCESS;
+}
+void StubApplet::ExecuteInteractive() {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    LogCurrentStorage(broker, "ExecuteInteractive");
+    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.SignalStateChanged();
+}
+void StubApplet::Execute() {
+    LOG_WARNING(Service_AM, "called (STUBBED)");
+    LogCurrentStorage(broker, "Execute");
+    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.SignalStateChanged();
+}
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/am/applets/stub_applet.h b/src/core/hle/service/am/applets/stub_applet.h
new file mode 100644
index 000000000..7d8dc968d
--- /dev/null
+++ b/src/core/hle/service/am/applets/stub_applet.h
@@ -0,0 +1,24 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+#pragma once
+#include "core/hle/service/am/applets/applets.h"
+namespace Service::AM::Applets {
+class StubApplet final : public Applet {
+public:
+    StubApplet();
+    ~StubApplet() override;
+    void Initialize() override;
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+};
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/audio/audout_u.cpp b/src/core/hle/service/audio/audout_u.cpp
index ff1edefbb..23e1f1165 100644
--- a/src/core/hle/service/audio/audout_u.cpp
+++ b/src/core/hle/service/audio/audout_u.cpp
@@ -44,8 +44,10 @@ enum class AudioState : u32 {
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
-    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core)
+    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core, std::string&& device_name,
-        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params) {
+              std::string&& unique_name)
+        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params),
+          device_name(std::move(device_name)) {
        static const FunctionInfo functions[] = {
            {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
@@ -69,7 +71,7 @@ public:
            Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
        stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
-                                       "IAudioOut", [=]() { buffer_event->Signal(); });
+                                       std::move(unique_name), [=]() { buffer_event->Signal(); });
    }
 private:
@@ -177,6 +179,7 @@ private:
    AudioCore::AudioOut& audio_core;
    AudioCore::StreamPtr stream;
+    std::string device_name;
    AudoutParams audio_params{};
@@ -199,7 +202,15 @@ void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
 void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_Audio, "called");
-    ctx.WriteBuffer(DefaultDevice);
+    const auto device_name_data{ctx.ReadBuffer()};
+    std::string device_name;
+    if (device_name_data[0] != '\0') {
+        device_name.assign(device_name_data.begin(), device_name_data.end());
+    } else {
+        device_name.assign(DefaultDevice.begin(), DefaultDevice.end());
+    }
+    ctx.WriteBuffer(device_name);
    IPC::RequestParser rp{ctx};
    auto params{rp.PopRaw<AudoutParams>()};
    if (params.channel_count <= 2) {
@@ -212,10 +223,9 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
        params.sample_rate = DefaultSampleRate;
    }
-    // TODO(bunnei): Support more than one IAudioOut interface. When we add this, ListAudioOutsImpl
+    std::string unique_name{fmt::format("{}-{}", device_name, audio_out_interfaces.size())};
-    // will likely need to be updated as well.
+    auto audio_out_interface = std::make_shared<IAudioOut>(
-    ASSERT_MSG(!audio_out_interface, "Unimplemented");
+        params, *audio_core, std::move(device_name), std::move(unique_name));
-    audio_out_interface = std::make_shared<IAudioOut>(params, *audio_core);
    IPC::ResponseBuilder rb{ctx, 6, 0, 1};
    rb.Push(RESULT_SUCCESS);
@@ -224,6 +234,8 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(static_cast<u32>(AudioCore::Codec::PcmFormat::Int16));
    rb.Push<u32>(static_cast<u32>(AudioState::Stopped));
    rb.PushIpcInterface<Audio::IAudioOut>(audio_out_interface);
+    audio_out_interfaces.push_back(std::move(audio_out_interface));
 }
 AudOutU::AudOutU() : ServiceFramework("audout:u") {
diff --git a/src/core/hle/service/audio/audout_u.h b/src/core/hle/service/audio/audout_u.h
index dcaf64708..aed4c43b2 100644
--- a/src/core/hle/service/audio/audout_u.h
+++ b/src/core/hle/service/audio/audout_u.h
@@ -4,6 +4,7 @@
 #pragma once
+#include <vector>
 #include "core/hle/service/service.h"
 namespace AudioCore {
@@ -24,7 +25,7 @@ public:
    ~AudOutU() override;
 private:
-    std::shared_ptr<IAudioOut> audio_out_interface;
+    std::vector<std::shared_ptr<IAudioOut>> audio_out_interfaces;
    std::unique_ptr<AudioCore::AudioOut> audio_core;
    void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp
index e76c83aee..c22357d8c 100644
--- a/src/core/hle/service/hid/controllers/debug_pad.cpp
+++ b/src/core/hle/service/hid/controllers/debug_pad.cpp
@@ -71,8 +71,9 @@ void Controller_DebugPad::OnUpdate(u8* data, std::size_t size) {
 void Controller_DebugPad::OnLoadInputDevices() {
    std::transform(Settings::values.debug_pad_buttons.begin(),
-                   Settings::values.debug_pad_buttons.end(), buttons.begin(),
+                   Settings::values.debug_pad_buttons.begin() +
-                   Input::CreateDevice<Input::ButtonDevice>);
+                       Settings::NativeButton::NUM_BUTTONS_HID,
+                   buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
    std::transform(Settings::values.debug_pad_analogs.begin(),
                   Settings::values.debug_pad_analogs.end(), analogs.begin(),
                   Input::CreateDevice<Input::AnalogDevice>);
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index b43f1f054..7a9d0d0dd 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -16,35 +16,18 @@
 namespace Service::LDR {
-namespace ErrCodes {
+constexpr ResultCode ERROR_INVALID_MEMORY_STATE{ErrorModule::Loader, 51};
-enum {
+constexpr ResultCode ERROR_INVALID_NRO{ErrorModule::Loader, 52};
-    InvalidMemoryState = 51,
+constexpr ResultCode ERROR_INVALID_NRR{ErrorModule::Loader, 53};
-    InvalidNRO = 52,
+constexpr ResultCode ERROR_MISSING_NRR_HASH{ErrorModule::Loader, 54};
-    InvalidNRR = 53,
+constexpr ResultCode ERROR_MAXIMUM_NRO{ErrorModule::Loader, 55};
-    MissingNRRHash = 54,
+constexpr ResultCode ERROR_MAXIMUM_NRR{ErrorModule::Loader, 56};
-    MaximumNRO = 55,
+constexpr ResultCode ERROR_ALREADY_LOADED{ErrorModule::Loader, 57};
-    MaximumNRR = 56,
+constexpr ResultCode ERROR_INVALID_ALIGNMENT{ErrorModule::Loader, 81};
-    AlreadyLoaded = 57,
+constexpr ResultCode ERROR_INVALID_SIZE{ErrorModule::Loader, 82};
-    InvalidAlignment = 81,
+constexpr ResultCode ERROR_INVALID_NRO_ADDRESS{ErrorModule::Loader, 84};
-    InvalidSize = 82,
+constexpr ResultCode ERROR_INVALID_NRR_ADDRESS{ErrorModule::Loader, 85};
-    InvalidNROAddress = 84,
+constexpr ResultCode ERROR_NOT_INITIALIZED{ErrorModule::Loader, 87};
-    InvalidNRRAddress = 85,
-    NotInitialized = 87,
-};
-}
-constexpr ResultCode ERROR_INVALID_MEMORY_STATE(ErrorModule::Loader, ErrCodes::InvalidMemoryState);
-constexpr ResultCode ERROR_INVALID_NRO(ErrorModule::Loader, ErrCodes::InvalidNRO);
-constexpr ResultCode ERROR_INVALID_NRR(ErrorModule::Loader, ErrCodes::InvalidNRR);
-constexpr ResultCode ERROR_MISSING_NRR_HASH(ErrorModule::Loader, ErrCodes::MissingNRRHash);
-constexpr ResultCode ERROR_MAXIMUM_NRO(ErrorModule::Loader, ErrCodes::MaximumNRO);
-constexpr ResultCode ERROR_MAXIMUM_NRR(ErrorModule::Loader, ErrCodes::MaximumNRR);
-constexpr ResultCode ERROR_ALREADY_LOADED(ErrorModule::Loader, ErrCodes::AlreadyLoaded);
-constexpr ResultCode ERROR_INVALID_ALIGNMENT(ErrorModule::Loader, ErrCodes::InvalidAlignment);
-constexpr ResultCode ERROR_INVALID_SIZE(ErrorModule::Loader, ErrCodes::InvalidSize);
-constexpr ResultCode ERROR_INVALID_NRO_ADDRESS(ErrorModule::Loader, ErrCodes::InvalidNROAddress);
-constexpr ResultCode ERROR_INVALID_NRR_ADDRESS(ErrorModule::Loader, ErrCodes::InvalidNRRAddress);
-constexpr ResultCode ERROR_NOT_INITIALIZED(ErrorModule::Loader, ErrCodes::NotInitialized);
 constexpr u64 MAXIMUM_LOADED_RO = 0x40;
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
index 7a88ae029..792d26e52 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
@@ -5,6 +5,8 @@
 #include <cstring>
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
 namespace Service::Nvidia::Devices {
@@ -33,6 +35,8 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vec
        return ZBCQueryTable(input, output);
    case IoctlCommand::IocFlushL2:
        return FlushL2(input, output);
+    case IoctlCommand::IocGetGpuTime:
+        return GetGpuTime(input, output);
    }
    UNIMPLEMENTED_MSG("Unimplemented ioctl");
    return 0;
@@ -169,4 +173,13 @@ u32 nvhost_ctrl_gpu::FlushL2(const std::vector<u8>& input, std::vector<u8>& outp
    return 0;
 }
+u32 nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output) {
+    LOG_DEBUG(Service_NVDRV, "called");
+    IoctlGetGpuTime params{};
+    std::memcpy(&params, input.data(), input.size());
+    params.gpu_time = CoreTiming::cyclesToNs(CoreTiming::GetTicks());
+    std::memcpy(output.data(), &params, output.size());
+    return 0;
+}
 } // namespace Service::Nvidia::Devices
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
index 3bbf028ad..240435eea 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
@@ -156,6 +156,11 @@ private:
    };
    static_assert(sizeof(IoctlFlushL2) == 8, "IoctlFlushL2 is incorrect size");
+    struct IoctlGetGpuTime {
+        u64_le gpu_time;
+    };
+    static_assert(sizeof(IoctlGetGpuTime) == 8, "IoctlGetGpuTime is incorrect size");
    u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
@@ -164,6 +169,7 @@ private:
    u32 ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output);
    u32 ZBCQueryTable(const std::vector<u8>& input, std::vector<u8>& output);
    u32 FlushL2(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetGpuTime(const std::vector<u8>& input, std::vector<u8>& output);
 };
 } // namespace Service::Nvidia::Devices
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index d25fdb1fe..a72416084 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -510,7 +510,11 @@ private:
        if (transaction == TransactionId::Connect) {
            IGBPConnectRequestParcel request{ctx.ReadBuffer()};
-            IGBPConnectResponseParcel response{1280, 720};
+            IGBPConnectResponseParcel response{
+                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) *
+                                 Settings::values.resolution_factor),
+                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) *
+                                 Settings::values.resolution_factor)};
            ctx.WriteBuffer(response.Serialize());
        } else if (transaction == TransactionId::SetPreallocatedBuffer) {
            IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()};
@@ -692,11 +696,15 @@ private:
        rb.Push(RESULT_SUCCESS);
        if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        } else {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        }
        rb.PushRaw<float>(60.0f);
@@ -901,11 +909,15 @@ private:
        rb.Push(RESULT_SUCCESS);
        if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u64>(DisplayResolution::DockedWidth));
+            rb.Push(static_cast<u64>(DisplayResolution::DockedWidth) *
-            rb.Push(static_cast<u64>(DisplayResolution::DockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u64>(DisplayResolution::DockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        } else {
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth));
+            rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
-            rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight));
+                    static_cast<u32>(Settings::values.resolution_factor));
+            rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
+                    static_cast<u32>(Settings::values.resolution_factor));
        }
    }
@@ -922,6 +934,8 @@ private:
    void ListDisplays(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        DisplayInfo display_info;
+        display_info.width *= static_cast<u64>(Settings::values.resolution_factor);
+        display_info.height *= static_cast<u64>(Settings::values.resolution_factor);
        ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
diff --git a/src/core/settings.h b/src/core/settings.h
index e63134f80..a0c5fd447 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -403,6 +403,7 @@ struct Values {
    bool use_gdbstub;
    u16 gdbstub_port;
    std::string program_args;
+    bool dump_exefs;
    bool dump_nso;
    // WebService
diff --git a/src/video_core/engines/maxwell_3d.cpp b/src/video_core/engines/maxwell_3d.cpp
index a04e00ecb..2bc534be3 100644
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -69,6 +69,15 @@ void Maxwell3D::InitializeRegisterDefaults() {
    // TODO(Rodrigo): Most games do not set a point size. I think this is a case of a
    // register carrying a default value. Assume it's OpenGL's default (1).
    regs.point_size = 1.0f;
+    // TODO(bunnei): Some games do not initialize the color masks (e.g. Sonic Mania). Assuming a
+    // default of enabled fixes rendering here.
+    for (std::size_t color_mask = 0; color_mask < Regs::NumRenderTargets; color_mask++) {
+        regs.color_mask[color_mask].R.Assign(1);
+        regs.color_mask[color_mask].G.Assign(1);
+        regs.color_mask[color_mask].B.Assign(1);
+        regs.color_mask[color_mask].A.Assign(1);
+    }
 }
 void Maxwell3D::CallMacroMethod(u32 method, std::vector<u32> parameters) {
diff --git a/src/video_core/engines/maxwell_3d.h b/src/video_core/engines/maxwell_3d.h
index 9e480dc39..4f137e693 100644
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -389,6 +389,13 @@ public:
                ReverseSubtract = 3,
                Min = 4,
                Max = 5,
+                // These values are used by Nouveau and some games.
+                AddGL = 0x8006,
+                SubtractGL = 0x8007,
+                ReverseSubtractGL = 0x8008,
+                MinGL = 0x800a,
+                MaxGL = 0x800b
            };
            enum class Factor : u32 {
@@ -624,7 +631,16 @@ public:
                    }
                } zeta;
-                INSERT_PADDING_WORDS(0x5B);
+                INSERT_PADDING_WORDS(0x41);
+                union {
+                    BitField<0, 4, u32> stencil;
+                    BitField<4, 4, u32> unknown;
+                    BitField<8, 4, u32> scissor;
+                    BitField<12, 4, u32> viewport;
+                } clear_flags;
+                INSERT_PADDING_WORDS(0x19);
                std::array<VertexAttribute, NumVertexAttributes> vertex_attrib_format;
@@ -1127,6 +1143,7 @@ ASSERT_REG_POSITION(stencil_back_func_mask, 0x3D7);
 ASSERT_REG_POSITION(color_mask_common, 0x3E4);
 ASSERT_REG_POSITION(rt_separate_frag_data, 0x3EB);
 ASSERT_REG_POSITION(zeta, 0x3F8);
+ASSERT_REG_POSITION(clear_flags, 0x43E);
 ASSERT_REG_POSITION(vertex_attrib_format, 0x458);
 ASSERT_REG_POSITION(rt_control, 0x487);
 ASSERT_REG_POSITION(zeta_width, 0x48a);
diff --git a/src/video_core/engines/shader_bytecode.h b/src/video_core/engines/shader_bytecode.h
index 83a6fd875..7e8449bc4 100644
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -153,6 +153,7 @@ enum class PredCondition : u64 {
    NotEqual = 5,
    GreaterEqual = 6,
    LessThanWithNan = 9,
+    LessEqualWithNan = 11,
    GreaterThanWithNan = 12,
    NotEqualWithNan = 13,
    GreaterEqualWithNan = 14,
@@ -261,7 +262,7 @@ enum class FlowCondition : u64 {
    Fcsm_Tr = 0x1C, // TODO(bunnei): What is this used for?
 };
-enum class ControlCode : u64 {
+enum class ConditionCode : u64 {
    F = 0,
    LT = 1,
    EQ = 2,
@@ -569,7 +570,6 @@ union Instruction {
        BitField<39, 2, u64> tab5cb8_2;
        BitField<41, 3, u64> tab5c68_1;
        BitField<44, 2, u64> tab5c68_0;
-        BitField<47, 1, u64> cc;
        BitField<48, 1, u64> negate_b;
    } fmul;
@@ -831,7 +831,7 @@ union Instruction {
    union {
        BitField<0, 3, u64> pred0;
        BitField<3, 3, u64> pred3;
-        BitField<8, 5, ControlCode> cc; // flag in cc
+        BitField<8, 5, ConditionCode> cc; // flag in cc
        BitField<39, 3, u64> pred39;
        BitField<42, 1, u64> neg_pred39;
        BitField<45, 4, PredOperation> op; // op with pred39
@@ -1235,7 +1235,7 @@ union Instruction {
    BitField<60, 1, u64> is_b_gpr;
    BitField<59, 1, u64> is_c_gpr;
    BitField<20, 24, s64> smem_imm;
-    BitField<0, 5, ControlCode> flow_control_code;
+    BitField<0, 5, ConditionCode> flow_condition_code;
    Attribute attribute;
    Sampler sampler;
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index 83c7e5b0b..51b3904f6 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -17,6 +17,8 @@ u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
    switch (format) {
    case PixelFormat::ABGR8:
        return 4;
+    default:
+        return 4;
    }
    UNREACHABLE();
diff --git a/src/video_core/macro_interpreter.cpp b/src/video_core/macro_interpreter.cpp
index 335a8d407..2b0dea5cd 100644
--- a/src/video_core/macro_interpreter.cpp
+++ b/src/video_core/macro_interpreter.cpp
@@ -35,6 +35,7 @@ void MacroInterpreter::Reset() {
    // The next parameter index starts at 1, because $r1 already has the value of the first
    // parameter.
    next_parameter_index = 1;
+    carry_flag = false;
 }
 bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
@@ -135,14 +136,28 @@ MacroInterpreter::Opcode MacroInterpreter::GetOpcode(u32 offset) const {
    return {macro_memory[offset + pc / sizeof(u32)]};
 }
-u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const {
+u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) {
    switch (operation) {
-    case ALUOperation::Add:
+    case ALUOperation::Add: {
-        return src_a + src_b;
+        const u64 result{static_cast<u64>(src_a) + src_b};
-    // TODO(Subv): Implement AddWithCarry
+        carry_flag = result > 0xffffffff;
-    case ALUOperation::Subtract:
+        return static_cast<u32>(result);
-        return src_a - src_b;
+    }
-    // TODO(Subv): Implement SubtractWithBorrow
+    case ALUOperation::AddWithCarry: {
+        const u64 result{static_cast<u64>(src_a) + src_b + (carry_flag ? 1ULL : 0ULL)};
+        carry_flag = result > 0xffffffff;
+        return static_cast<u32>(result);
+    }
+    case ALUOperation::Subtract: {
+        const u64 result{static_cast<u64>(src_a) - src_b};
+        carry_flag = result < 0x100000000;
+        return static_cast<u32>(result);
+    }
+    case ALUOperation::SubtractWithBorrow: {
+        const u64 result{static_cast<u64>(src_a) - src_b - (carry_flag ? 0ULL : 1ULL)};
+        carry_flag = result < 0x100000000;
+        return static_cast<u32>(result);
+    }
    case ALUOperation::Xor:
        return src_a ^ src_b;
    case ALUOperation::Or:
diff --git a/src/video_core/macro_interpreter.h b/src/video_core/macro_interpreter.h
index 62d1ce289..cde360288 100644
--- a/src/video_core/macro_interpreter.h
+++ b/src/video_core/macro_interpreter.h
@@ -117,7 +117,7 @@ private:
    bool Step(u32 offset, bool is_delay_slot);
    /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const;
+    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b);
    /// Performs the result operation on the input result and stores it in the specified register
    /// (if necessary).
@@ -165,5 +165,7 @@ private:
    std::vector<u32> parameters;
    /// Index of the next parameter that will be fetched by the 'parm' instruction.
    u32 next_parameter_index = 0;
+    bool carry_flag{};
 };
 } // namespace Tegra
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 8e5ca298f..630a58e49 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -537,6 +537,30 @@ void RasterizerOpenGL::Clear() {
        ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear stencil but buffer is not enabled!");
        use_stencil = true;
        clear_state.stencil.test_enabled = true;
+        if (regs.clear_flags.stencil) {
+            // Stencil affects the clear so fill it with the used masks
+            clear_state.stencil.front.test_func = GL_ALWAYS;
+            clear_state.stencil.front.test_mask = regs.stencil_front_func_mask;
+            clear_state.stencil.front.action_stencil_fail = GL_KEEP;
+            clear_state.stencil.front.action_depth_fail = GL_KEEP;
+            clear_state.stencil.front.action_depth_pass = GL_KEEP;
+            clear_state.stencil.front.write_mask = regs.stencil_front_mask;
+            if (regs.stencil_two_side_enable) {
+                clear_state.stencil.back.test_func = GL_ALWAYS;
+                clear_state.stencil.back.test_mask = regs.stencil_back_func_mask;
+                clear_state.stencil.back.action_stencil_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_pass = GL_KEEP;
+                clear_state.stencil.back.write_mask = regs.stencil_back_mask;
+            } else {
+                clear_state.stencil.back.test_func = GL_ALWAYS;
+                clear_state.stencil.back.test_mask = 0xFFFFFFFF;
+                clear_state.stencil.back.write_mask = 0xFFFFFFFF;
+                clear_state.stencil.back.action_stencil_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_fail = GL_KEEP;
+                clear_state.stencil.back.action_depth_pass = GL_KEEP;
+            }
+        }
    }
    if (!use_color && !use_depth && !use_stencil) {
@@ -548,6 +572,14 @@ void RasterizerOpenGL::Clear() {
    ConfigureFramebuffers(clear_state, use_color, use_depth || use_stencil, false,
                          regs.clear_buffers.RT.Value());
+    if (regs.clear_flags.scissor) {
+        SyncScissorTest(clear_state);
+    }
+    if (regs.clear_flags.viewport) {
+        clear_state.EmulateViewportWithScissor();
+    }
    clear_state.Apply();
    if (use_color) {
@@ -583,7 +615,7 @@ void RasterizerOpenGL::DrawArrays() {
    SyncLogicOpState();
    SyncCullMode();
    SyncPrimitiveRestart();
-    SyncScissorTest();
+    SyncScissorTest(state);
    // Alpha Testing is synced on shaders.
    SyncTransformFeedback();
    SyncPointState();
@@ -810,7 +842,7 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
    }
    const u32 bias = config.mip_lod_bias.Value();
    // Sign extend the 13-bit value.
-    const u32 mask = 1U << (13 - 1);
+    constexpr u32 mask = 1U << (13 - 1);
    const float bias_lod = static_cast<s32>((bias ^ mask) - mask) / 256.f;
    if (lod_bias != bias_lod) {
        lod_bias = bias_lod;
@@ -942,8 +974,8 @@ void RasterizerOpenGL::SyncViewport(OpenGLState& current_state) {
        auto& viewport = current_state.viewports[i];
        viewport.x = viewport_rect.left;
        viewport.y = viewport_rect.bottom;
-        viewport.width = static_cast<GLfloat>(viewport_rect.GetWidth());
+        viewport.width = viewport_rect.GetWidth();
-        viewport.height = static_cast<GLfloat>(viewport_rect.GetHeight());
+        viewport.height = viewport_rect.GetHeight();
        viewport.depth_range_far = regs.viewports[i].depth_range_far;
        viewport.depth_range_near = regs.viewports[i].depth_range_near;
    }
@@ -1115,11 +1147,11 @@ void RasterizerOpenGL::SyncLogicOpState() {
    state.logic_op.operation = MaxwellToGL::LogicOp(regs.logic_op.operation);
 }
-void RasterizerOpenGL::SyncScissorTest() {
+void RasterizerOpenGL::SyncScissorTest(OpenGLState& current_state) {
    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
    for (std::size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumViewports; i++) {
        const auto& src = regs.scissor_test[i];
-        auto& dst = state.viewports[i].scissor;
+        auto& dst = current_state.viewports[i].scissor;
        dst.enabled = (src.enable != 0);
        if (dst.enabled == 0) {
            return;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h
index fd6c8c3c5..f4354289c 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -91,19 +91,20 @@ private:
        void SyncWithConfig(const Tegra::Texture::TSCEntry& info);
    private:
-        Tegra::Texture::TextureFilter mag_filter;
+        Tegra::Texture::TextureFilter mag_filter = Tegra::Texture::TextureFilter::Nearest;
-        Tegra::Texture::TextureFilter min_filter;
+        Tegra::Texture::TextureFilter min_filter = Tegra::Texture::TextureFilter::Nearest;
-        Tegra::Texture::TextureMipmapFilter mip_filter;
+        Tegra::Texture::TextureMipmapFilter mip_filter = Tegra::Texture::TextureMipmapFilter::None;
-        Tegra::Texture::WrapMode wrap_u;
+        Tegra::Texture::WrapMode wrap_u = Tegra::Texture::WrapMode::ClampToEdge;
-        Tegra::Texture::WrapMode wrap_v;
+        Tegra::Texture::WrapMode wrap_v = Tegra::Texture::WrapMode::ClampToEdge;
-        Tegra::Texture::WrapMode wrap_p;
+        Tegra::Texture::WrapMode wrap_p = Tegra::Texture::WrapMode::ClampToEdge;
-        bool uses_depth_compare;
+        bool uses_depth_compare = false;
-        Tegra::Texture::DepthCompareFunc depth_compare_func;
+        Tegra::Texture::DepthCompareFunc depth_compare_func =
-        GLvec4 border_color;
+            Tegra::Texture::DepthCompareFunc::Always;
-        float min_lod;
+        GLvec4 border_color = {};
-        float max_lod;
+        float min_lod = 0.0f;
-        float lod_bias;
+        float max_lod = 16.0f;
-        float max_anisotropic;
+        float lod_bias = 0.0f;
+        float max_anisotropic = 1.0f;
    };
    /**
@@ -171,7 +172,7 @@ private:
    void SyncMultiSampleState();
    /// Syncs the scissor test state to match the guest state
-    void SyncScissorTest();
+    void SyncScissorTest(OpenGLState& current_state);
    /// Syncs the transform feedback state to match the guest state
    void SyncTransformFeedback();
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index 83e6a4b50..4f434fc31 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -1275,6 +1275,31 @@ Surface RasterizerCacheOpenGL::GetUncachedSurface(const SurfaceParams& params) {
    return surface;
 }
+void RasterizerCacheOpenGL::FastLayeredCopySurface(const Surface& src_surface,
+                                                   const Surface& dst_surface) {
+    const auto& init_params{src_surface->GetSurfaceParams()};
+    const auto& dst_params{dst_surface->GetSurfaceParams()};
+    VAddr address = init_params.addr;
+    const std::size_t layer_size = dst_params.LayerMemorySize();
+    for (u32 layer = 0; layer < dst_params.depth; layer++) {
+        for (u32 mipmap = 0; mipmap < dst_params.max_mip_level; mipmap++) {
+            const VAddr sub_address = address + dst_params.GetMipmapLevelOffset(mipmap);
+            const Surface& copy = TryGet(sub_address);
+            if (!copy)
+                continue;
+            const auto& src_params{copy->GetSurfaceParams()};
+            const u32 width{std::min(src_params.width, dst_params.MipWidth(mipmap))};
+            const u32 height{std::min(src_params.height, dst_params.MipHeight(mipmap))};
+            glCopyImageSubData(copy->Texture().handle, SurfaceTargetToGL(src_params.target), 0, 0,
+                               0, 0, dst_surface->Texture().handle,
+                               SurfaceTargetToGL(dst_params.target), mipmap, 0, 0, layer, width,
+                               height, 1);
+        }
+        address += layer_size;
+    }
+}
 void RasterizerCacheOpenGL::FermiCopySurface(
    const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
    const Tegra::Engines::Fermi2D::Regs::Surface& dst_config) {
@@ -1340,11 +1365,13 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
            CopySurface(old_surface, new_surface, copy_pbo.handle);
        }
        break;
-    case SurfaceTarget::TextureCubemap:
    case SurfaceTarget::Texture3D:
+        AccurateCopySurface(old_surface, new_surface);
+        break;
+    case SurfaceTarget::TextureCubemap:
    case SurfaceTarget::Texture2DArray:
    case SurfaceTarget::TextureCubeArray:
-        AccurateCopySurface(old_surface, new_surface);
+        FastLayeredCopySurface(old_surface, new_surface);
        break;
    default:
        LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index 494f6b903..9ac79c5a4 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -350,6 +350,7 @@ private:
    /// Performs a slow but accurate surface copy, flushing to RAM and reinterpreting the data
    void AccurateCopySurface(const Surface& src_surface, const Surface& dst_surface);
+    void FastLayeredCopySurface(const Surface& src_surface, const Surface& dst_surface);
    /// The surface reserve is a "backup" cache, this is where we put unique surfaces that have
    /// previously been used. This is to prevent surfaces from being constantly created and
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index a85a7c0c5..038b25c75 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -84,6 +84,7 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
    }
    entries = program_result.second;
+    shader_length = entries.shader_length;
    if (program_type != Maxwell::ShaderProgram::Geometry) {
        OGLShader shader;
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.h b/src/video_core/renderer_opengl/gl_shader_cache.h
index ffbf21831..08f470de3 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_cache.h
@@ -30,7 +30,7 @@ public:
    }
    std::size_t GetSizeInBytes() const override {
-        return GLShader::MAX_PROGRAM_CODE_LENGTH * sizeof(u64);
+        return shader_length;
    }
    // We do not have to flush this cache as things in it are never modified by us.
@@ -82,6 +82,7 @@ private:
                               u32 max_vertices, const std::string& debug_name);
    VAddr addr;
+    std::size_t shader_length;
    Maxwell::ShaderProgram program_type;
    GLShader::ShaderSetup setup;
    GLShader::ShaderEntries entries;
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 5fde22ad4..97b9028c5 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -34,6 +34,17 @@ constexpr u32 PROGRAM_HEADER_SIZE = sizeof(Tegra::Shader::Header);
 constexpr u32 MAX_GEOMETRY_BUFFERS = 6;
 constexpr u32 MAX_ATTRIBUTES = 0x100; // Size in vec4s, this value is untested
+static const char* INTERNAL_FLAG_NAMES[] = {"zero_flag", "sign_flag", "carry_flag",
+                                            "overflow_flag"};
+enum class InternalFlag : u64 {
+    ZeroFlag = 0,
+    SignFlag = 1,
+    CarryFlag = 2,
+    OverflowFlag = 3,
+    Amount
+};
 class DecompileFail : public std::runtime_error {
 public:
    using std::runtime_error::runtime_error;
@@ -49,8 +60,7 @@ static std::string GetTopologyName(Tegra::Shader::OutputTopology topology) {
    case Tegra::Shader::OutputTopology::TriangleStrip:
        return "triangle_strip";
    default:
-        LOG_CRITICAL(Render_OpenGL, "Unknown output topology {}", static_cast<u32>(topology));
+        UNIMPLEMENTED_MSG("Unknown output topology: {}", static_cast<u32>(topology));
-        UNREACHABLE();
        return "points";
    }
 }
@@ -85,7 +95,8 @@ struct Subroutine {
 class ControlFlowAnalyzer {
 public:
    ControlFlowAnalyzer(const ProgramCode& program_code, u32 main_offset, const std::string& suffix)
-        : program_code(program_code) {
+        : program_code(program_code), shader_coverage_begin(main_offset),
+          shader_coverage_end(main_offset + 1) {
        // Recursively finds all subroutines.
        const Subroutine& program_main = AddSubroutine(main_offset, PROGRAM_END, suffix);
@@ -97,10 +108,16 @@ public:
        return std::move(subroutines);
    }
+    std::size_t GetShaderLength() const {
+        return shader_coverage_end * sizeof(u64);
+    }
 private:
    const ProgramCode& program_code;
    std::set<Subroutine> subroutines;
    std::map<std::pair<u32, u32>, ExitMethod> exit_method_map;
+    u32 shader_coverage_begin;
+    u32 shader_coverage_end;
    /// Adds and analyzes a new subroutine if it is not added yet.
    const Subroutine& AddSubroutine(u32 begin, u32 end, const std::string& suffix) {
@@ -142,6 +159,9 @@ private:
            return exit_method;
        for (u32 offset = begin; offset != end && offset != PROGRAM_END; ++offset) {
+            shader_coverage_begin = std::min(shader_coverage_begin, offset);
+            shader_coverage_end = std::max(shader_coverage_end, offset + 1);
            const Instruction instr = {program_code[offset]};
            if (const auto opcode = OpCode::Decode(instr)) {
                switch (opcode->get().GetId()) {
@@ -167,8 +187,8 @@ private:
                case OpCode::Id::SSY:
                case OpCode::Id::PBK: {
                    // The SSY and PBK use a similar encoding as the BRA instruction.
-                    ASSERT_MSG(instr.bra.constant_buffer == 0,
+                    UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
-                               "Constant buffer branching is not supported");
+                                         "Constant buffer branching is not supported");
                    const u32 target = offset + instr.bra.GetBranchTarget();
                    labels.insert(target);
                    // Continue scanning for an exit method.
@@ -258,14 +278,6 @@ private:
    const std::string& suffix;
 };
-enum class InternalFlag : u64 {
-    ZeroFlag = 0,
-    CarryFlag = 1,
-    OverflowFlag = 2,
-    NaNFlag = 3,
-    Amount
-};
 /**
 * Used to manage shader registers that are emulated with GLSL. This class keeps track of the state
 * of all registers (e.g. whether they are currently being used as Floats or Integers), and
@@ -299,8 +311,7 @@ public:
            // Default - do nothing
            return value;
        default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented conversion size {}", static_cast<u32>(size));
+            UNIMPLEMENTED_MSG("Unimplemented conversion size: {}", static_cast<u32>(size));
-            UNREACHABLE();
        }
    }
@@ -363,7 +374,7 @@ public:
                              u64 value_num_components, bool is_saturated = false,
                              u64 dest_elem = 0, Register::Size size = Register::Size::Word,
                              bool sets_cc = false) {
-        ASSERT_MSG(!is_saturated, "Unimplemented");
+        UNIMPLEMENTED_IF(is_saturated);
        const std::string func{is_signed ? "intBitsToFloat" : "uintBitsToFloat"};
@@ -373,7 +384,7 @@ public:
        if (sets_cc) {
            const std::string zero_condition = "( " + ConvertIntegerSize(value, size) + " == 0 )";
            SetInternalFlag(InternalFlag::ZeroFlag, zero_condition);
-            LOG_WARNING(HW_GPU, "Control Codes Imcomplete.");
+            LOG_WARNING(HW_GPU, "Condition codes implementation is incomplete.");
        }
    }
@@ -392,7 +403,7 @@ public:
                                Tegra::Shader::HalfMerge merge, u64 dest_num_components,
                                u64 value_num_components, bool is_saturated = false,
                                u64 dest_elem = 0) {
-        ASSERT_MSG(!is_saturated, "Unimplemented");
+        UNIMPLEMENTED_IF(is_saturated);
        const std::string result = [&]() {
            switch (merge) {
@@ -456,24 +467,25 @@ public:
        shader.AddLine("lmem[" + index + "] = " + func + '(' + value + ");");
    }
-    std::string GetControlCode(const Tegra::Shader::ControlCode cc) const {
+    std::string GetConditionCode(const Tegra::Shader::ConditionCode cc) const {
        switch (cc) {
-        case Tegra::Shader::ControlCode::NEU:
+        case Tegra::Shader::ConditionCode::NEU:
            return "!(" + GetInternalFlag(InternalFlag::ZeroFlag) + ')';
        default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented Control Code {}", static_cast<u32>(cc));
+            UNIMPLEMENTED_MSG("Unimplemented condition code: {}", static_cast<u32>(cc));
-            UNREACHABLE();
            return "false";
        }
    }
-    std::string GetInternalFlag(const InternalFlag ii) const {
+    std::string GetInternalFlag(const InternalFlag flag) const {
-        const u32 code = static_cast<u32>(ii);
+        const auto index = static_cast<u32>(flag);
-        return "internalFlag_" + std::to_string(code) + suffix;
+        ASSERT(index < static_cast<u32>(InternalFlag::Amount));
+        return std::string(INTERNAL_FLAG_NAMES[index]) + '_' + suffix;
    }
-    void SetInternalFlag(const InternalFlag ii, const std::string& value) const {
+    void SetInternalFlag(const InternalFlag flag, const std::string& value) const {
-        shader.AddLine(GetInternalFlag(ii) + " = " + value + ';');
+        shader.AddLine(GetInternalFlag(flag) + " = " + value + ';');
    }
    /**
@@ -624,8 +636,8 @@ private:
    /// Generates declarations for internal flags.
    void GenerateInternalFlags() {
-        for (u32 ii = 0; ii < static_cast<u64>(InternalFlag::Amount); ii++) {
+        for (u32 flag = 0; flag < static_cast<u32>(InternalFlag::Amount); flag++) {
-            const InternalFlag code = static_cast<InternalFlag>(ii);
+            const InternalFlag code = static_cast<InternalFlag>(flag);
            declarations.AddLine("bool " + GetInternalFlag(code) + " = false;");
        }
        declarations.AddNewLine();
@@ -761,8 +773,7 @@ private:
                     u64 dest_num_components, u64 value_num_components, u64 dest_elem,
                     bool precise) {
        if (reg == Register::ZeroIndex) {
-            LOG_CRITICAL(HW_GPU, "Cannot set Register::ZeroIndex");
+            // Setting RZ is a nop in hardware.
-            UNREACHABLE();
            return;
        }
@@ -847,16 +858,13 @@ private:
                if (declr_input_attribute.count(attribute) == 0) {
                    declr_input_attribute[attribute] = input_mode;
                } else {
-                    if (declr_input_attribute[attribute] != input_mode) {
+                    UNIMPLEMENTED_IF_MSG(declr_input_attribute[attribute] != input_mode,
-                        LOG_CRITICAL(HW_GPU, "Same Input multiple input modes");
+                                         "Multiple input modes for the same attribute");
-                        UNREACHABLE();
-                    }
                }
                return GeometryPass("input_attribute_" + std::to_string(index));
            }
-            LOG_CRITICAL(HW_GPU, "Unhandled input attribute: {}", static_cast<u32>(attribute));
+            UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
-            UNREACHABLE();
        }
        return "vec4(0, 0, 0, 0)";
@@ -882,24 +890,20 @@ private:
            break;
        }
        default: {
-            LOG_CRITICAL(HW_GPU, "Unhandled Ipa InterpMode: {}", static_cast<u32>(interp_mode));
+            UNIMPLEMENTED_MSG("Unhandled IPA interp mode: {}", static_cast<u32>(interp_mode));
-            UNREACHABLE();
        }
        }
        switch (sample_mode) {
-        case Tegra::Shader::IpaSampleMode::Centroid: {
+        case Tegra::Shader::IpaSampleMode::Centroid:
-            // Note not implemented, it can be implemented with the "centroid " keyword in glsl;
+            // It can be implemented with the "centroid " keyword in glsl
-            LOG_CRITICAL(HW_GPU, "Ipa Sampler Mode: centroid, not implemented");
+            UNIMPLEMENTED_MSG("Unimplemented IPA sampler mode centroid");
-            UNREACHABLE();
            break;
-        }
+        case Tegra::Shader::IpaSampleMode::Default:
-        case Tegra::Shader::IpaSampleMode::Default: {
            // Default, n/a
            break;
-        }
        default: {
-            LOG_CRITICAL(HW_GPU, "Unhandled Ipa SampleMode: {}", static_cast<u32>(sample_mode));
+            UNIMPLEMENTED_MSG("Unimplemented IPA sampler mode: {}", static_cast<u32>(sample_mode));
-            UNREACHABLE();
+            break;
        }
        }
        return out;
@@ -920,8 +924,7 @@ private:
                return "output_attribute_" + std::to_string(index);
            }
-            LOG_CRITICAL(HW_GPU, "Unhandled output attribute: {}", index);
+            UNIMPLEMENTED_MSG("Unhandled output attribute={}", index);
-            UNREACHABLE();
            return {};
        }
    }
@@ -951,9 +954,10 @@ private:
 class GLSLGenerator {
 public:
    GLSLGenerator(const std::set<Subroutine>& subroutines, const ProgramCode& program_code,
-                  u32 main_offset, Maxwell3D::Regs::ShaderStage stage, const std::string& suffix)
+                  u32 main_offset, Maxwell3D::Regs::ShaderStage stage, const std::string& suffix,
+                  std::size_t shader_length)
        : subroutines(subroutines), program_code(program_code), main_offset(main_offset),
-          stage(stage), suffix(suffix) {
+          stage(stage), suffix(suffix), shader_length(shader_length) {
        std::memcpy(&header, program_code.data(), sizeof(Tegra::Shader::Header));
        local_memory_size = header.GetLocalMemorySize();
        regs.SetLocalMemory(local_memory_size);
@@ -966,7 +970,7 @@ public:
    /// Returns entries in the shader that are useful for external functions
    ShaderEntries GetEntries() const {
-        return {regs.GetConstBuffersDeclarations(), regs.GetSamplers()};
+        return {regs.GetConstBuffersDeclarations(), regs.GetSamplers(), shader_length};
    }
 private:
@@ -1071,19 +1075,26 @@ private:
                                       const std::string& op_a, const std::string& op_b) const {
        using Tegra::Shader::PredCondition;
        static const std::unordered_map<PredCondition, const char*> PredicateComparisonStrings = {
-            {PredCondition::LessThan, "<"},           {PredCondition::Equal, "=="},
+            {PredCondition::LessThan, "<"},
-            {PredCondition::LessEqual, "<="},         {PredCondition::GreaterThan, ">"},
+            {PredCondition::Equal, "=="},
-            {PredCondition::NotEqual, "!="},          {PredCondition::GreaterEqual, ">="},
+            {PredCondition::LessEqual, "<="},
-            {PredCondition::LessThanWithNan, "<"},    {PredCondition::NotEqualWithNan, "!="},
+            {PredCondition::GreaterThan, ">"},
-            {PredCondition::GreaterThanWithNan, ">"}, {PredCondition::GreaterEqualWithNan, ">="}};
+            {PredCondition::NotEqual, "!="},
+            {PredCondition::GreaterEqual, ">="},
+            {PredCondition::LessThanWithNan, "<"},
+            {PredCondition::NotEqualWithNan, "!="},
+            {PredCondition::LessEqualWithNan, "<="},
+            {PredCondition::GreaterThanWithNan, ">"},
+            {PredCondition::GreaterEqualWithNan, ">="}};
        const auto& comparison{PredicateComparisonStrings.find(condition)};
-        ASSERT_MSG(comparison != PredicateComparisonStrings.end(),
+        UNIMPLEMENTED_IF_MSG(comparison == PredicateComparisonStrings.end(),
-                   "Unknown predicate comparison operation");
+                             "Unknown predicate comparison operation");
        std::string predicate{'(' + op_a + ") " + comparison->second + " (" + op_b + ')'};
        if (condition == PredCondition::LessThanWithNan ||
            condition == PredCondition::NotEqualWithNan ||
+            condition == PredCondition::LessEqualWithNan ||
            condition == PredCondition::GreaterThanWithNan ||
            condition == PredCondition::GreaterEqualWithNan) {
            predicate += " || isnan(" + op_a + ") || isnan(" + op_b + ')';
@@ -1107,7 +1118,7 @@ private:
        };
        auto op = PredicateOperationStrings.find(operation);
-        ASSERT_MSG(op != PredicateOperationStrings.end(), "Unknown predicate operation");
+        UNIMPLEMENTED_IF_MSG(op == PredicateOperationStrings.end(), "Unknown predicate operation");
        return op->second;
    }
@@ -1205,8 +1216,7 @@ private:
            break;
        }
        default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented logic operation: {}", static_cast<u32>(logic_op));
+            UNIMPLEMENTED_MSG("Unimplemented logic operation={}", static_cast<u32>(logic_op));
-            UNREACHABLE();
        }
        if (dest != Tegra::Shader::Register::ZeroIndex) {
@@ -1224,9 +1234,8 @@ private:
            SetPredicate(static_cast<u64>(predicate), '(' + result + ") != 0");
            break;
        default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented predicate result mode: {}",
+            UNIMPLEMENTED_MSG("Unimplemented predicate result mode: {}",
-                         static_cast<u32>(predicate_mode));
+                              static_cast<u32>(predicate_mode));
-            UNREACHABLE();
        }
    }
@@ -1257,14 +1266,7 @@ private:
        regs.SetRegisterToInteger(dest, true, 0, result, 1, 1);
    }
-    void WriteTexsInstruction(const Instruction& instr, const std::string& coord,
+    void WriteTexsInstruction(const Instruction& instr, const std::string& texture) {
-                              const std::string& texture) {
-        // Add an extra scope and declare the texture coords inside to prevent
-        // overwriting them in case they are used as outputs of the texs instruction.
-        shader.AddLine('{');
-        ++shader.scope;
-        shader.AddLine(coord);
        // TEXS has two destination registers and a swizzle. The first two elements in the swizzle
        // go into gpr0+0 and gpr0+1, and the rest goes into gpr28+0 and gpr28+1
@@ -1287,26 +1289,19 @@ private:
            ++written_components;
        }
-        --shader.scope;
-        shader.AddLine('}');
    }
    static u32 TextureCoordinates(Tegra::Shader::TextureType texture_type) {
        switch (texture_type) {
-        case Tegra::Shader::TextureType::Texture1D: {
+        case Tegra::Shader::TextureType::Texture1D:
            return 1;
-        }
+        case Tegra::Shader::TextureType::Texture2D:
-        case Tegra::Shader::TextureType::Texture2D: {
            return 2;
-        }
        case Tegra::Shader::TextureType::Texture3D:
-        case Tegra::Shader::TextureType::TextureCube: {
+        case Tegra::Shader::TextureType::TextureCube:
            return 3;
-        }
        default:
-            LOG_CRITICAL(HW_GPU, "Unhandled texture type {}", static_cast<u32>(texture_type));
+            UNIMPLEMENTED_MSG("Unhandled texture type: {}", static_cast<u32>(texture_type));
-            UNREACHABLE();
            return 0;
        }
    }
@@ -1342,7 +1337,7 @@ private:
    void EmitFragmentOutputsWrite() {
        ASSERT(stage == Maxwell3D::Regs::ShaderStage::Fragment);
-        ASSERT_MSG(header.ps.omap.sample_mask == 0, "Samplemask write is unimplemented");
+        UNIMPLEMENTED_IF_MSG(header.ps.omap.sample_mask != 0, "Samplemask write is unimplemented");
        shader.AddLine("if (alpha_test[0] != 0) {");
        ++shader.scope;
@@ -1408,7 +1403,7 @@ private:
            case Tegra::Shader::VideoType::Size32:
                // TODO(Rodrigo): From my hardware tests it becomes a bit "mad" when
                // this type is used (1 * 1 + 0 == 0x5b800000). Until a better
-                // explanation is found: assert.
+                // explanation is found: abort.
                UNIMPLEMENTED();
                return zero;
            case Tegra::Shader::VideoType::Invalid:
@@ -1464,8 +1459,7 @@ private:
        // Decoding failure
        if (!opcode) {
-            LOG_CRITICAL(HW_GPU, "Unhandled instruction: {0:x}", instr.value);
+            UNIMPLEMENTED_MSG("Unhandled instruction: {0:x}", instr.value);
-            UNREACHABLE();
            return offset + 1;
        }
@@ -1473,8 +1467,8 @@ private:
            fmt::format("// {}: {} (0x{:016x})", offset, opcode->get().GetName(), instr.value));
        using Tegra::Shader::Pred;
-        ASSERT_MSG(instr.pred.full_pred != Pred::NeverExecute,
+        UNIMPLEMENTED_IF_MSG(instr.pred.full_pred == Pred::NeverExecute,
-                   "NeverExecute predicate not implemented");
+                             "NeverExecute predicate not implemented");
        // Some instructions (like SSY) don't have a predicate field, they are always
        // unconditionally executed.
@@ -1517,37 +1511,36 @@ private:
            case OpCode::Id::FMUL_R:
            case OpCode::Id::FMUL_IMM: {
                // FMUL does not have 'abs' bits and only the second operand has a 'neg' bit.
-                ASSERT_MSG(instr.fmul.tab5cb8_2 == 0, "FMUL tab5cb8_2({}) is not implemented",
+                UNIMPLEMENTED_IF_MSG(instr.fmul.tab5cb8_2 != 0,
-                           instr.fmul.tab5cb8_2.Value());
+                                     "FMUL tab5cb8_2({}) is not implemented",
-                ASSERT_MSG(instr.fmul.tab5c68_1 == 0, "FMUL tab5cb8_1({}) is not implemented",
+                                     instr.fmul.tab5cb8_2.Value());
-                           instr.fmul.tab5c68_1.Value());
+                UNIMPLEMENTED_IF_MSG(instr.fmul.tab5c68_1 != 0,
-                ASSERT_MSG(instr.fmul.tab5c68_0 == 1, "FMUL tab5cb8_0({}) is not implemented",
+                                     "FMUL tab5cb8_1({}) is not implemented",
-                           instr.fmul.tab5c68_0
+                                     instr.fmul.tab5c68_1.Value());
-                               .Value()); // SMO typical sends 1 here which seems to be the default
+                UNIMPLEMENTED_IF_MSG(
-                ASSERT_MSG(instr.fmul.cc == 0, "FMUL cc is not implemented");
+                    instr.fmul.tab5c68_0 != 1, "FMUL tab5cb8_0({}) is not implemented",
+                    instr.fmul.tab5c68_0
+                        .Value()); // SMO typical sends 1 here which seems to be the default
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in FMUL is not implemented");
                op_b = GetOperandAbsNeg(op_b, false, instr.fmul.negate_b);
                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b, 1, 1,
                                        instr.alu.saturate_d, 0, true);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FMUL Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::FADD_C:
            case OpCode::Id::FADD_R:
            case OpCode::Id::FADD_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in FADD is not implemented");
                op_a = GetOperandAbsNeg(op_a, instr.alu.abs_a, instr.alu.negate_a);
                op_b = GetOperandAbsNeg(op_b, instr.alu.abs_b, instr.alu.negate_b);
                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1,
                                        instr.alu.saturate_d, 0, true);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FADD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::MUFU: {
@@ -1582,15 +1575,17 @@ private:
                                            instr.alu.saturate_d, 0, true);
                    break;
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled MUFU sub op: {0:x}",
+                    UNIMPLEMENTED_MSG("Unhandled MUFU sub op={0:x}",
-                                 static_cast<unsigned>(instr.sub_op.Value()));
+                                      static_cast<unsigned>(instr.sub_op.Value()));
-                    UNREACHABLE();
                }
                break;
            }
            case OpCode::Id::FMNMX_C:
            case OpCode::Id::FMNMX_R:
            case OpCode::Id::FMNMX_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in FMNMX is not implemented");
                op_a = GetOperandAbsNeg(op_a, instr.alu.abs_a, instr.alu.negate_a);
                op_b = GetOperandAbsNeg(op_b, instr.alu.abs_b, instr.alu.negate_b);
@@ -1601,10 +1596,6 @@ private:
                                        '(' + condition + ") ? min(" + parameters + ") : max(" +
                                            parameters + ')',
                                        1, 1, false, 0, true);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FMNMX Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::RRO_C:
@@ -1617,9 +1608,7 @@ private:
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled arithmetic instruction: {}",
+                UNIMPLEMENTED_MSG("Unhandled arithmetic instruction: {}", opcode->get().GetName());
-                             opcode->get().GetName());
-                UNREACHABLE();
            }
            }
            break;
@@ -1631,17 +1620,19 @@ private:
                break;
            }
            case OpCode::Id::FMUL32_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
+                                     "Condition codes generation in FMUL32 is not implemented");
                regs.SetRegisterToFloat(instr.gpr0, 0,
                                        regs.GetRegisterAsFloat(instr.gpr8) + " * " +
                                            GetImmediate32(instr),
                                        1, 1, instr.fmul32.saturate, 0, true);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FMUL32 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::FADD32I: {
+                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
+                                     "Condition codes generation in FADD32I is not implemented");
                std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
                std::string op_b = GetImmediate32(instr);
@@ -1662,23 +1653,22 @@ private:
                }
                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1, false, 0, true);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FADD32 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            }
            break;
        }
        case OpCode::Type::Bfe: {
-            ASSERT_MSG(!instr.bfe.negate_b, "Unimplemented");
+            UNIMPLEMENTED_IF(instr.bfe.negate_b);
            std::string op_a = instr.bfe.negate_a ? "-" : "";
            op_a += regs.GetRegisterAsInteger(instr.gpr8);
            switch (opcode->get().GetId()) {
            case OpCode::Id::BFE_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in BFE is not implemented");
                std::string inner_shift =
                    '(' + op_a + " << " + std::to_string(instr.bfe.GetLeftShiftValue()) + ')';
                std::string outer_shift =
@@ -1686,15 +1676,10 @@ private:
                    std::to_string(instr.bfe.GetLeftShiftValue() + instr.bfe.shift_position) + ')';
                regs.SetRegisterToInteger(instr.gpr0, true, 0, outer_shift, 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "BFE Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled BFE instruction: {}", opcode->get().GetName());
+                UNIMPLEMENTED_MSG("Unhandled BFE instruction: {}", opcode->get().GetName());
-                UNREACHABLE();
            }
            }
@@ -1719,6 +1704,9 @@ private:
            case OpCode::Id::SHR_C:
            case OpCode::Id::SHR_R:
            case OpCode::Id::SHR_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in SHR is not implemented");
                if (!instr.shift.is_signed) {
                    // Logical shift right
                    op_a = "uint(" + op_a + ')';
@@ -1727,24 +1715,17 @@ private:
                // Cast to int is superfluous for arithmetic shift, it's only for a logical shift
                regs.SetRegisterToInteger(instr.gpr0, true, 0, "int(" + op_a + " >> " + op_b + ')',
                                          1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "SHR Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::SHL_C:
            case OpCode::Id::SHL_R:
            case OpCode::Id::SHL_IMM:
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in SHL is not implemented");
                regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " << " + op_b, 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "SHL Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled shift instruction: {}", opcode->get().GetName());
+                UNIMPLEMENTED_MSG("Unhandled shift instruction: {}", opcode->get().GetName());
-                UNREACHABLE();
            }
            }
            break;
@@ -1755,17 +1736,19 @@ private:
            switch (opcode->get().GetId()) {
            case OpCode::Id::IADD32I:
+                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
+                                     "Condition codes generation in IADD32I is not implemented");
                if (instr.iadd32i.negate_a)
                    op_a = "-(" + op_a + ')';
                regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " + " + op_b, 1, 1,
                                          instr.iadd32i.saturate != 0);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IADD32 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            case OpCode::Id::LOP32I: {
+                UNIMPLEMENTED_IF_MSG(instr.op_32.generates_cc,
+                                     "Condition codes generation in LOP32I is not implemented");
                if (instr.alu.lop32i.invert_a)
                    op_a = "~(" + op_a + ')';
@@ -1775,16 +1758,11 @@ private:
                WriteLogicOperation(instr.gpr0, instr.alu.lop32i.operation, op_a, op_b,
                                    Tegra::Shader::PredicateResultMode::None,
                                    Tegra::Shader::Pred::UnusedIndex);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "LOP32I Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled ArithmeticIntegerImmediate instruction: {}",
+                UNIMPLEMENTED_MSG("Unhandled ArithmeticIntegerImmediate instruction: {}",
-                             opcode->get().GetName());
+                                  opcode->get().GetName());
-                UNREACHABLE();
            }
            }
            break;
@@ -1807,6 +1785,9 @@ private:
            case OpCode::Id::IADD_C:
            case OpCode::Id::IADD_R:
            case OpCode::Id::IADD_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in IADD is not implemented");
                if (instr.alu_integer.negate_a)
                    op_a = "-(" + op_a + ')';
@@ -1815,15 +1796,14 @@ private:
                regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " + " + op_b, 1, 1,
                                          instr.alu.saturate_d);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IADD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::IADD3_C:
            case OpCode::Id::IADD3_R:
            case OpCode::Id::IADD3_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in IADD3 is not implemented");
                std::string op_c = regs.GetRegisterAsInteger(instr.gpr39);
                auto apply_height = [](auto height, auto& oprand) {
@@ -1837,9 +1817,8 @@ private:
                        oprand = "((" + oprand + ") >> 16)";
                        break;
                    default:
-                        LOG_CRITICAL(HW_GPU, "Unhandled IADD3 height: {}",
+                        UNIMPLEMENTED_MSG("Unhandled IADD3 height: {}",
-                                     static_cast<u32>(height.Value()));
+                                          static_cast<u32>(height.Value()));
-                        UNREACHABLE();
                    }
                };
@@ -1880,16 +1859,14 @@ private:
                }
                regs.SetRegisterToInteger(instr.gpr0, true, 0, result, 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IADD3 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::ISCADD_C:
            case OpCode::Id::ISCADD_R:
            case OpCode::Id::ISCADD_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in ISCADD is not implemented");
                if (instr.alu_integer.negate_a)
                    op_a = "-(" + op_a + ')';
@@ -1900,10 +1877,6 @@ private:
                regs.SetRegisterToInteger(instr.gpr0, true, 0,
                                          "((" + op_a + " << " + shift + ") + " + op_b + ')', 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "ISCADD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::POPC_C:
@@ -1927,6 +1900,9 @@ private:
            case OpCode::Id::LOP_C:
            case OpCode::Id::LOP_R:
            case OpCode::Id::LOP_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in LOP is not implemented");
                if (instr.alu.lop.invert_a)
                    op_a = "~(" + op_a + ')';
@@ -1935,15 +1911,14 @@ private:
                WriteLogicOperation(instr.gpr0, instr.alu.lop.operation, op_a, op_b,
                                    instr.alu.lop.pred_result_mode, instr.alu.lop.pred48);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "LOP Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::LOP3_C:
            case OpCode::Id::LOP3_R:
            case OpCode::Id::LOP3_IMM: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in LOP3 is not implemented");
                const std::string op_c = regs.GetRegisterAsInteger(instr.gpr39);
                std::string lut;
@@ -1954,17 +1929,15 @@ private:
                }
                WriteLop3Instruction(instr.gpr0, op_a, op_b, op_c, lut);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "LOP3 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::IMNMX_C:
            case OpCode::Id::IMNMX_R:
            case OpCode::Id::IMNMX_IMM: {
-                ASSERT_MSG(instr.imnmx.exchange == Tegra::Shader::IMinMaxExchange::None,
+                UNIMPLEMENTED_IF(instr.imnmx.exchange != Tegra::Shader::IMinMaxExchange::None);
-                           "Unimplemented");
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in IMNMX is not implemented");
                const std::string condition =
                    GetPredicateCondition(instr.imnmx.pred, instr.imnmx.negate_pred != 0);
                const std::string parameters = op_a + ',' + op_b;
@@ -1972,10 +1945,6 @@ private:
                                          '(' + condition + ") ? min(" + parameters + ") : max(" +
                                              parameters + ')',
                                          1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IMNMX Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::LEA_R2:
@@ -2030,24 +1999,19 @@ private:
                    op_b = regs.GetRegisterAsInteger(instr.gpr8);
                    op_a = std::to_string(instr.lea.imm.entry_a);
                    op_c = std::to_string(instr.lea.imm.entry_b);
-                    LOG_CRITICAL(HW_GPU, "Unhandled LEA subinstruction: {}",
+                    UNIMPLEMENTED_MSG("Unhandled LEA subinstruction: {}", opcode->get().GetName());
-                                 opcode->get().GetName());
-                    UNREACHABLE();
-                }
                }
-                if (instr.lea.pred48 != static_cast<u64>(Pred::UnusedIndex)) {
-                    LOG_ERROR(HW_GPU, "Unhandled LEA Predicate");
-                    UNREACHABLE();
                }
+                UNIMPLEMENTED_IF_MSG(instr.lea.pred48 != static_cast<u64>(Pred::UnusedIndex),
+                                     "Unhandled LEA Predicate");
                const std::string value = '(' + op_a + " + (" + op_b + "*(1 << " + op_c + ")))";
                regs.SetRegisterToInteger(instr.gpr0, true, 0, value, 1, 1);
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled ArithmeticInteger instruction: {}",
+                UNIMPLEMENTED_MSG("Unhandled ArithmeticInteger instruction: {}",
-                             opcode->get().GetName());
+                                  opcode->get().GetName());
-                UNREACHABLE();
            }
            }
@@ -2056,7 +2020,7 @@ private:
        case OpCode::Type::ArithmeticHalf: {
            if (opcode->get().GetId() == OpCode::Id::HADD2_C ||
                opcode->get().GetId() == OpCode::Id::HADD2_R) {
-                ASSERT_MSG(instr.alu_half.ftz == 0, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.alu_half.ftz != 0);
            }
            const bool negate_a =
                opcode->get().GetId() != OpCode::Id::HMUL2_R && instr.alu_half.negate_a != 0;
@@ -2094,9 +2058,8 @@ private:
                case OpCode::Id::HMUL2_R:
                    return '(' + op_a + " * " + op_b + ')';
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled half float instruction: {}",
+                    UNIMPLEMENTED_MSG("Unhandled half float instruction: {}",
-                                 opcode->get().GetName());
+                                      opcode->get().GetName());
-                    UNREACHABLE();
                    return std::string("0");
                }
            }();
@@ -2107,10 +2070,10 @@ private:
        }
        case OpCode::Type::ArithmeticHalfImmediate: {
            if (opcode->get().GetId() == OpCode::Id::HADD2_IMM) {
-                ASSERT_MSG(instr.alu_half_imm.ftz == 0, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.alu_half_imm.ftz != 0);
            } else {
-                ASSERT_MSG(instr.alu_half_imm.precision == Tegra::Shader::HalfPrecision::None,
+                UNIMPLEMENTED_IF(instr.alu_half_imm.precision !=
-                           "Unimplemented");
+                                 Tegra::Shader::HalfPrecision::None);
            }
            const std::string op_a = GetHalfFloat(
@@ -2140,11 +2103,14 @@ private:
            std::string op_b = instr.ffma.negate_b ? "-" : "";
            std::string op_c = instr.ffma.negate_c ? "-" : "";
-            ASSERT_MSG(instr.ffma.cc == 0, "FFMA cc not implemented");
+            UNIMPLEMENTED_IF_MSG(instr.ffma.cc != 0, "FFMA cc not implemented");
-            ASSERT_MSG(instr.ffma.tab5980_0 == 1, "FFMA tab5980_0({}) not implemented",
+            UNIMPLEMENTED_IF_MSG(
-                       instr.ffma.tab5980_0.Value()); // Seems to be 1 by default based on SMO
+                instr.ffma.tab5980_0 != 1, "FFMA tab5980_0({}) not implemented",
-            ASSERT_MSG(instr.ffma.tab5980_1 == 0, "FFMA tab5980_1({}) not implemented",
+                instr.ffma.tab5980_0.Value()); // Seems to be 1 by default based on SMO
-                       instr.ffma.tab5980_1.Value());
+            UNIMPLEMENTED_IF_MSG(instr.ffma.tab5980_1 != 0, "FFMA tab5980_1({}) not implemented",
+                                 instr.ffma.tab5980_1.Value());
+            UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                 "Condition codes generation in FFMA is not implemented");
            switch (opcode->get().GetId()) {
            case OpCode::Id::FFMA_CR: {
@@ -2170,27 +2136,19 @@ private:
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled FFMA instruction: {}", opcode->get().GetName());
+                UNIMPLEMENTED_MSG("Unhandled FFMA instruction: {}", opcode->get().GetName());
-                UNREACHABLE();
            }
            }
            regs.SetRegisterToFloat(instr.gpr0, 0, "fma(" + op_a + ", " + op_b + ", " + op_c + ')',
                                    1, 1, instr.alu.saturate_d, 0, true);
-            if (instr.generates_cc) {
-                LOG_CRITICAL(HW_GPU, "FFMA Generates an unhandled Control Code");
-                UNREACHABLE();
-            }
            break;
        }
        case OpCode::Type::Hfma2: {
            if (opcode->get().GetId() == OpCode::Id::HFMA2_RR) {
-                ASSERT_MSG(instr.hfma2.rr.precision == Tegra::Shader::HalfPrecision::None,
+                UNIMPLEMENTED_IF(instr.hfma2.rr.precision != Tegra::Shader::HalfPrecision::None);
-                           "Unimplemented");
            } else {
-                ASSERT_MSG(instr.hfma2.precision == Tegra::Shader::HalfPrecision::None,
+                UNIMPLEMENTED_IF(instr.hfma2.precision != Tegra::Shader::HalfPrecision::None);
-                           "Unimplemented");
            }
            const bool saturate = opcode->get().GetId() == OpCode::Id::HFMA2_RR
                                      ? instr.hfma2.rr.saturate != 0
@@ -2240,7 +2198,7 @@ private:
        case OpCode::Type::Conversion: {
            switch (opcode->get().GetId()) {
            case OpCode::Id::I2I_R: {
-                ASSERT_MSG(!instr.conversion.selector, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.conversion.selector);
                std::string op_a = regs.GetRegisterAsInteger(
                    instr.gpr20, 0, instr.conversion.is_input_signed, instr.conversion.src_size);
@@ -2260,8 +2218,10 @@ private:
            }
            case OpCode::Id::I2F_R:
            case OpCode::Id::I2F_C: {
-                ASSERT_MSG(instr.conversion.dest_size == Register::Size::Word, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.conversion.dest_size != Register::Size::Word);
-                ASSERT_MSG(!instr.conversion.selector, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.conversion.selector);
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in I2F is not implemented");
                std::string op_a{};
@@ -2286,16 +2246,13 @@ private:
                }
                regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "I2F Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::F2F_R: {
-                ASSERT_MSG(instr.conversion.dest_size == Register::Size::Word, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.conversion.dest_size != Register::Size::Word);
-                ASSERT_MSG(instr.conversion.src_size == Register::Size::Word, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.conversion.src_size != Register::Size::Word);
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in F2F is not implemented");
                std::string op_a = regs.GetRegisterAsFloat(instr.gpr20);
                if (instr.conversion.abs_a) {
@@ -2322,23 +2279,19 @@ private:
                    op_a = "trunc(" + op_a + ')';
                    break;
                default:
-                    LOG_CRITICAL(HW_GPU, "Unimplemented f2f rounding mode {}",
+                    UNIMPLEMENTED_MSG("Unimplemented F2F rounding mode {}",
-                                 static_cast<u32>(instr.conversion.f2f.rounding.Value()));
+                                      static_cast<u32>(instr.conversion.f2f.rounding.Value()));
-                    UNREACHABLE();
                    break;
                }
                regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1, instr.alu.saturate_d);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "F2F Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::F2I_R:
            case OpCode::Id::F2I_C: {
-                ASSERT_MSG(instr.conversion.src_size == Register::Size::Word, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.conversion.src_size != Register::Size::Word);
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in F2I is not implemented");
                std::string op_a{};
                if (instr.is_b_gpr) {
@@ -2369,9 +2322,8 @@ private:
                    op_a = "trunc(" + op_a + ')';
                    break;
                default:
-                    LOG_CRITICAL(HW_GPU, "Unimplemented f2i rounding mode {}",
+                    UNIMPLEMENTED_MSG("Unimplemented F2I rounding mode {}",
-                                 static_cast<u32>(instr.conversion.f2i.rounding.Value()));
+                                      static_cast<u32>(instr.conversion.f2i.rounding.Value()));
-                    UNREACHABLE();
                    break;
                }
@@ -2383,16 +2335,10 @@ private:
                regs.SetRegisterToInteger(instr.gpr0, instr.conversion.is_output_signed, 0, op_a, 1,
                                          1, false, 0, instr.conversion.dest_size);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "F2I Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled conversion instruction: {}",
+                UNIMPLEMENTED_MSG("Unhandled conversion instruction: {}", opcode->get().GetName());
-                             opcode->get().GetName());
-                UNREACHABLE();
            }
            }
            break;
@@ -2401,10 +2347,10 @@ private:
            switch (opcode->get().GetId()) {
            case OpCode::Id::LD_A: {
                // Note: Shouldn't this be interp mode flat? As in no interpolation made.
-                ASSERT_MSG(instr.gpr8.Value() == Register::ZeroIndex,
+                UNIMPLEMENTED_IF_MSG(instr.gpr8.Value() != Register::ZeroIndex,
-                           "Indirect attribute loads are not supported");
+                                     "Indirect attribute loads are not supported");
-                ASSERT_MSG((instr.attribute.fmt20.immediate.Value() % sizeof(u32)) == 0,
+                UNIMPLEMENTED_IF_MSG((instr.attribute.fmt20.immediate.Value() % sizeof(u32)) != 0,
-                           "Unaligned attribute loads are not supported");
+                                     "Unaligned attribute loads are not supported");
                Tegra::Shader::IpaMode input_mode{Tegra::Shader::IpaInterpMode::Perspective,
                                                  Tegra::Shader::IpaSampleMode::Default};
@@ -2431,7 +2377,7 @@ private:
                break;
            }
            case OpCode::Id::LD_C: {
-                ASSERT_MSG(instr.ld_c.unknown == 0, "Unimplemented");
+                UNIMPLEMENTED_IF(instr.ld_c.unknown != 0);
                // Add an extra scope and declare the index register inside to prevent
                // overwriting it in case it is used as an output of the LD instruction.
@@ -2459,9 +2405,8 @@ private:
                    break;
                }
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled type: {}",
+                    UNIMPLEMENTED_MSG("Unhandled type: {}",
-                                 static_cast<unsigned>(instr.ld_c.type.Value()));
+                                      static_cast<unsigned>(instr.ld_c.type.Value()));
-                    UNREACHABLE();
                }
                --shader.scope;
@@ -2469,6 +2414,9 @@ private:
                break;
            }
            case OpCode::Id::LD_L: {
+                UNIMPLEMENTED_IF_MSG(instr.ld_l.unknown == 1, "LD_L Unhandled mode: {}",
+                                     static_cast<unsigned>(instr.ld_l.unknown.Value()));
                // Add an extra scope and declare the index register inside to prevent
                // overwriting it in case it is used as an output of the LD instruction.
                shader.AddLine('{');
@@ -2481,20 +2429,13 @@ private:
                const std::string op_a = regs.GetLocalMemoryAsFloat("index");
-                if (instr.ld_l.unknown != 1) {
-                    LOG_CRITICAL(HW_GPU, "LD_L Unhandled mode: {}",
-                                 static_cast<unsigned>(instr.ld_l.unknown.Value()));
-                    UNREACHABLE();
-                }
                switch (instr.ldst_sl.type.Value()) {
                case Tegra::Shader::StoreType::Bytes32:
                    regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1);
                    break;
                default:
-                    LOG_CRITICAL(HW_GPU, "LD_L Unhandled type: {}",
+                    UNIMPLEMENTED_MSG("LD_L Unhandled type: {}",
-                                 static_cast<unsigned>(instr.ldst_sl.type.Value()));
+                                      static_cast<unsigned>(instr.ldst_sl.type.Value()));
-                    UNREACHABLE();
                }
                --shader.scope;
@@ -2502,10 +2443,10 @@ private:
                break;
            }
            case OpCode::Id::ST_A: {
-                ASSERT_MSG(instr.gpr8.Value() == Register::ZeroIndex,
+                UNIMPLEMENTED_IF_MSG(instr.gpr8.Value() != Register::ZeroIndex,
-                           "Indirect attribute loads are not supported");
+                                     "Indirect attribute loads are not supported");
-                ASSERT_MSG((instr.attribute.fmt20.immediate.Value() % sizeof(u32)) == 0,
+                UNIMPLEMENTED_IF_MSG((instr.attribute.fmt20.immediate.Value() % sizeof(u32)) != 0,
-                           "Unaligned attribute loads are not supported");
+                                     "Unaligned attribute loads are not supported");
                u64 next_element = instr.attribute.fmt20.element;
                u64 next_index = static_cast<u64>(instr.attribute.fmt20.index.Value());
@@ -2530,6 +2471,9 @@ private:
                break;
            }
            case OpCode::Id::ST_L: {
+                UNIMPLEMENTED_IF_MSG(instr.st_l.unknown == 0, "ST_L Unhandled mode: {}",
+                                     static_cast<unsigned>(instr.st_l.unknown.Value()));
                // Add an extra scope and declare the index register inside to prevent
                // overwriting it in case it is used as an output of the LD instruction.
                shader.AddLine('{');
@@ -2540,20 +2484,13 @@ private:
                shader.AddLine("uint index = (" + op + " / 4);");
-                if (instr.st_l.unknown != 0) {
-                    LOG_CRITICAL(HW_GPU, "ST_L Unhandled mode: {}",
-                                 static_cast<unsigned>(instr.st_l.unknown.Value()));
-                    UNREACHABLE();
-                }
                switch (instr.ldst_sl.type.Value()) {
                case Tegra::Shader::StoreType::Bytes32:
                    regs.SetLocalMemoryAsFloat("index", regs.GetRegisterAsFloat(instr.gpr0));
                    break;
                default:
-                    LOG_CRITICAL(HW_GPU, "ST_L Unhandled type: {}",
+                    UNIMPLEMENTED_MSG("ST_L Unhandled type: {}",
-                                 static_cast<unsigned>(instr.ldst_sl.type.Value()));
+                                      static_cast<unsigned>(instr.ldst_sl.type.Value()));
-                    UNREACHABLE();
                }
                --shader.scope;
@@ -2565,10 +2502,10 @@ private:
                std::string coord;
                const bool is_array = instr.tex.array != 0;
-                ASSERT_MSG(!instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
+                UNIMPLEMENTED_IF_MSG(instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
-                           "NODEP is not implemented");
+                                     "NODEP is not implemented");
-                ASSERT_MSG(!instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
+                UNIMPLEMENTED_IF_MSG(instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
-                           "AOFFI is not implemented");
+                                     "AOFFI is not implemented");
                const bool depth_compare =
                    instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
@@ -2634,9 +2571,8 @@ private:
                    break;
                }
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled coordinates number {}",
+                    UNIMPLEMENTED_MSG("Unhandled coordinates number {}",
-                                 static_cast<u32>(num_coordinates));
+                                      static_cast<u32>(num_coordinates));
-                    UNREACHABLE();
                    // Fallback to interpreting as a 2D texture for now
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
@@ -2646,7 +2582,6 @@ private:
                }
                // TODO: make sure coordinates are always indexed to gpr8 and gpr20 is always bias
                // or lod.
-                std::string op_c;
                const std::string sampler =
                    GetSampler(instr.sampler, texture_type, is_array, depth_compare);
@@ -2669,34 +2604,41 @@ private:
                }
                case Tegra::Shader::TextureProcessMode::LB:
                case Tegra::Shader::TextureProcessMode::LBA: {
-                    if (depth_compare) {
+                    const std::string bias = [&]() {
-                        if (is_array)
+                        if (depth_compare) {
-                            op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 2);
+                            if (is_array)
-                        else
+                                return regs.GetRegisterAsFloat(instr.gpr20.Value() + 2);
-                            op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                            else
-                    } else {
+                                return regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                        } else {
-                    }
+                            return regs.GetRegisterAsFloat(instr.gpr20);
+                        }
+                    }();
+                    shader.AddLine("float bias = " + bias + ';');
                    // TODO: Figure if A suffix changes the equation at all.
-                    texture = "texture(" + sampler + ", coords, " + op_c + ')';
+                    texture = "texture(" + sampler + ", coords, bias)";
                    break;
                }
                case Tegra::Shader::TextureProcessMode::LL:
                case Tegra::Shader::TextureProcessMode::LLA: {
-                    if (num_coordinates <= 2) {
+                    const std::string lod = [&]() {
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                        if (num_coordinates <= 2) {
-                    } else {
+                            return regs.GetRegisterAsFloat(instr.gpr20);
-                        op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                        } else {
-                    }
+                            return regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                        }
+                    }();
+                    shader.AddLine("float lod = " + lod + ';');
                    // TODO: Figure if A suffix changes the equation at all.
-                    texture = "textureLod(" + sampler + ", coords, " + op_c + ')';
+                    texture = "textureLod(" + sampler + ", coords, lod)";
                    break;
                }
                default: {
                    texture = "texture(" + sampler + ", coords)";
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture process mode {}",
+                    UNIMPLEMENTED_MSG("Unhandled texture process mode {}",
-                                 static_cast<u32>(instr.tex.GetTextureProcessMode()));
+                                      static_cast<u32>(instr.tex.GetTextureProcessMode()));
-                    UNREACHABLE();
                }
                }
                if (!depth_compare) {
@@ -2717,12 +2659,11 @@ private:
                break;
            }
            case OpCode::Id::TEXS: {
-                std::string coord;
                Tegra::Shader::TextureType texture_type{instr.texs.GetTextureType()};
                bool is_array{instr.texs.IsArrayTexture()};
-                ASSERT_MSG(!instr.texs.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
+                UNIMPLEMENTED_IF_MSG(instr.texs.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
-                           "NODEP is not implemented");
+                                     "NODEP is not implemented");
                const bool depth_compare =
                    instr.texs.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
@@ -2730,17 +2671,21 @@ private:
                if (depth_compare)
                    num_coordinates += 1;
+                // Scope to avoid variable name overlaps.
+                shader.AddLine('{');
+                ++shader.scope;
                switch (num_coordinates) {
                case 2: {
                    if (is_array) {
                        const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                        const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + index + ");";
+                        shader.AddLine("vec3 coords = vec3(" + x + ", " + y + ", " + index + ");");
                    } else {
                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                        const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                        shader.AddLine("vec2 coords = vec2(" + x + ", " + y + ");");
                    }
                    break;
                }
@@ -2750,25 +2695,24 @@ private:
                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                        const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
                        const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord =
+                        shader.AddLine("vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " +
-                            "vec4 coords = vec4(" + x + ", " + y + ", " + z + ", " + index + ");";
+                                       index + ");");
                    } else {
                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                        const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                        const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                        shader.AddLine("vec3 coords = vec3(" + x + ", " + y + ", " + z + ");");
                    }
                    break;
                }
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled coordinates number {}",
+                    UNIMPLEMENTED_MSG("Unhandled coordinates number {}",
-                                 static_cast<u32>(num_coordinates));
+                                      static_cast<u32>(num_coordinates));
-                    UNREACHABLE();
                    // Fallback to interpreting as a 2D texture for now
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
-                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                    shader.AddLine("vec2 coords = vec2(" + x + ", " + y + ");");
                    texture_type = Tegra::Shader::TextureType::Texture2D;
                    is_array = false;
                }
@@ -2795,57 +2739,57 @@ private:
                }
                default: {
                    texture = "texture(" + sampler + ", coords)";
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture process mode {}",
+                    UNIMPLEMENTED_MSG("Unhandled texture process mode {}",
-                                 static_cast<u32>(instr.texs.GetTextureProcessMode()));
+                                      static_cast<u32>(instr.texs.GetTextureProcessMode()));
-                    UNREACHABLE();
                }
                }
                if (!depth_compare) {
-                    WriteTexsInstruction(instr, coord, texture);
+                    WriteTexsInstruction(instr, texture);
                } else {
-                    WriteTexsInstruction(instr, coord, "vec4(" + texture + ')');
+                    WriteTexsInstruction(instr, "vec4(" + texture + ')');
                }
+                shader.AddLine('}');
+                --shader.scope;
                break;
            }
            case OpCode::Id::TLDS: {
-                std::string coord;
                const Tegra::Shader::TextureType texture_type{instr.tlds.GetTextureType()};
                const bool is_array{instr.tlds.IsArrayTexture()};
                ASSERT(texture_type == Tegra::Shader::TextureType::Texture2D);
                ASSERT(is_array == false);
-                ASSERT_MSG(!instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
+                UNIMPLEMENTED_IF_MSG(instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
-                           "NODEP is not implemented");
+                                     "NODEP is not implemented");
-                ASSERT_MSG(!instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
+                UNIMPLEMENTED_IF_MSG(instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
-                           "AOFFI is not implemented");
+                                     "AOFFI is not implemented");
-                ASSERT_MSG(!instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::MZ),
+                UNIMPLEMENTED_IF_MSG(instr.tlds.UsesMiscMode(Tegra::Shader::TextureMiscMode::MZ),
-                           "MZ is not implemented");
+                                     "MZ is not implemented");
-                u32 op_c_offset = 0;
+                u32 extra_op_offset = 0;
+                // Scope to avoid variable name overlaps.
+                shader.AddLine('{');
+                ++shader.scope;
                switch (texture_type) {
                case Tegra::Shader::TextureType::Texture1D: {
                    const std::string x = regs.GetRegisterAsInteger(instr.gpr8);
-                    coord = "int coords = " + x + ';';
+                    shader.AddLine("int coords = " + x + ';');
                    break;
                }
                case Tegra::Shader::TextureType::Texture2D: {
-                    if (is_array) {
+                    UNIMPLEMENTED_IF_MSG(is_array, "Unhandled 2d array texture");
-                        LOG_CRITICAL(HW_GPU, "Unhandled 2d array texture");
-                        UNREACHABLE();
+                    const std::string x = regs.GetRegisterAsInteger(instr.gpr8);
-                    } else {
+                    const std::string y = regs.GetRegisterAsInteger(instr.gpr20);
-                        const std::string x = regs.GetRegisterAsInteger(instr.gpr8);
+                    shader.AddLine("ivec2 coords = ivec2(" + x + ", " + y + ");");
-                        const std::string y = regs.GetRegisterAsInteger(instr.gpr20);
+                    extra_op_offset = 1;
-                        coord = "ivec2 coords = ivec2(" + x + ", " + y + ");";
-                        op_c_offset = 1;
-                    }
                    break;
                }
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
+                    UNIMPLEMENTED_MSG("Unhandled texture type {}", static_cast<u32>(texture_type));
-                                 static_cast<u32>(texture_type));
-                    UNREACHABLE();
                }
                const std::string sampler =
                    GetSampler(instr.sampler, texture_type, is_array, false);
@@ -2856,19 +2800,22 @@ private:
                    break;
                }
                case Tegra::Shader::TextureProcessMode::LL: {
-                    const std::string op_c =
+                    shader.AddLine(
-                        regs.GetRegisterAsInteger(instr.gpr20.Value() + op_c_offset);
+                        "float lod = " +
-                    texture = "texelFetch(" + sampler + ", coords, " + op_c + ')';
+                        regs.GetRegisterAsInteger(instr.gpr20.Value() + extra_op_offset) + ';');
+                    texture = "texelFetch(" + sampler + ", coords, lod)";
                    break;
                }
                default: {
                    texture = "texelFetch(" + sampler + ", coords, 0)";
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture process mode {}",
+                    UNIMPLEMENTED_MSG("Unhandled texture process mode {}",
-                                 static_cast<u32>(instr.tlds.GetTextureProcessMode()));
+                                      static_cast<u32>(instr.tlds.GetTextureProcessMode()));
-                    UNREACHABLE();
                }
                }
-                WriteTexsInstruction(instr, coord, texture);
+                WriteTexsInstruction(instr, texture);
+                --shader.scope;
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TLD4: {
@@ -2876,14 +2823,14 @@ private:
                ASSERT(instr.tld4.array == 0);
                std::string coord;
-                ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
+                UNIMPLEMENTED_IF_MSG(instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
-                           "NODEP is not implemented");
+                                     "NODEP is not implemented");
-                ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
+                UNIMPLEMENTED_IF_MSG(instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
-                           "AOFFI is not implemented");
+                                     "AOFFI is not implemented");
-                ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::NDV),
+                UNIMPLEMENTED_IF_MSG(instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::NDV),
-                           "NDV is not implemented");
+                                     "NDV is not implemented");
-                ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::PTP),
+                UNIMPLEMENTED_IF_MSG(instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::PTP),
-                           "PTP is not implemented");
+                                     "PTP is not implemented");
                const bool depth_compare =
                    instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
                auto texture_type = instr.tld4.texture_type.Value();
@@ -2891,37 +2838,37 @@ private:
                if (depth_compare)
                    num_coordinates += 1;
+                // Add an extra scope and declare the texture coords inside to prevent
+                // overwriting them in case they are used as outputs of the texs instruction.
+                shader.AddLine('{');
+                ++shader.scope;
                switch (num_coordinates) {
                case 2: {
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                    shader.AddLine("vec2 coords = vec2(" + x + ", " + y + ");");
                    break;
                }
                case 3: {
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                    const std::string z = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    shader.AddLine("vec3 coords = vec3(" + x + ", " + y + ", " + z + ");");
                    break;
                }
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled coordinates number {}",
+                    UNIMPLEMENTED_MSG("Unhandled coordinates number {}",
-                                 static_cast<u32>(num_coordinates));
+                                      static_cast<u32>(num_coordinates));
-                    UNREACHABLE();
                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                    shader.AddLine("vec2 coords = vec2(" + x + ", " + y + ");");
                    texture_type = Tegra::Shader::TextureType::Texture2D;
                }
                const std::string sampler =
                    GetSampler(instr.sampler, texture_type, false, depth_compare);
-                // Add an extra scope and declare the texture coords inside to prevent
-                // overwriting them in case they are used as outputs of the texs instruction.
-                shader.AddLine("{");
-                ++shader.scope;
-                shader.AddLine(coord);
                const std::string texture = "textureGather(" + sampler + ", coords, " +
                                            std::to_string(instr.tld4.component) + ')';
                if (!depth_compare) {
@@ -2938,14 +2885,20 @@ private:
                    regs.SetRegisterToFloat(instr.gpr0, 0, texture, 1, 1, false);
                }
                --shader.scope;
-                shader.AddLine("}");
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TLD4S: {
-                ASSERT_MSG(!instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
+                UNIMPLEMENTED_IF_MSG(
-                           "NODEP is not implemented");
+                    instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
-                ASSERT_MSG(!instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
+                    "NODEP is not implemented");
-                           "AOFFI is not implemented");
+                UNIMPLEMENTED_IF_MSG(
+                    instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
+                    "AOFFI is not implemented");
+                // Scope to avoid variable name overlaps.
+                shader.AddLine('{');
+                ++shader.scope;
                const bool depth_compare =
                    instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
@@ -2954,28 +2907,33 @@ private:
                // TODO(Subv): Figure out how the sampler type is encoded in the TLD4S instruction.
                const std::string sampler = GetSampler(
                    instr.sampler, Tegra::Shader::TextureType::Texture2D, false, depth_compare);
-                std::string coord;
                if (!depth_compare) {
-                    coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
+                    shader.AddLine("vec2 coords = vec2(" + op_a + ", " + op_b + ");");
                } else {
                    // Note: TLD4S coordinate encoding works just like TEXS's
-                    const std::string op_c = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    shader.AddLine(
-                    coord = "vec3 coords = vec3(" + op_a + ", " + op_c + ", " + op_b + ");";
+                        "float op_y = " + regs.GetRegisterAsFloat(instr.gpr8.Value() + 1) + ';');
+                    shader.AddLine("vec3 coords = vec3(" + op_a + ", op_y, " + op_b + ");");
                }
                const std::string texture = "textureGather(" + sampler + ", coords, " +
                                            std::to_string(instr.tld4s.component) + ')';
                if (!depth_compare) {
-                    WriteTexsInstruction(instr, coord, texture);
+                    WriteTexsInstruction(instr, texture);
                } else {
-                    WriteTexsInstruction(instr, coord, "vec4(" + texture + ')');
+                    WriteTexsInstruction(instr, "vec4(" + texture + ')');
                }
+                --shader.scope;
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TXQ: {
-                ASSERT_MSG(!instr.txq.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
+                UNIMPLEMENTED_IF_MSG(instr.txq.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
-                           "NODEP is not implemented");
+                                     "NODEP is not implemented");
+                ++shader.scope;
+                shader.AddLine('{');
                // TODO: the new commits on the texture refactor, change the way samplers work.
                // Sadly, not all texture instructions specify the type of texture their sampler
                // uses. This must be fixed at a later instance.
@@ -2983,23 +2941,30 @@ private:
                    GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false, false);
                switch (instr.txq.query_type) {
                case Tegra::Shader::TextureQueryType::Dimension: {
-                    const std::string texture = "textureQueryLevels(" + sampler + ')';
+                    const std::string texture = "textureSize(" + sampler + ", " +
-                    regs.SetRegisterToInteger(instr.gpr0, true, 0, texture, 1, 1);
+                                                regs.GetRegisterAsInteger(instr.gpr8) + ')';
+                    const std::string mip_level = "textureQueryLevels(" + sampler + ')';
+                    shader.AddLine("ivec2 sizes = " + texture + ';');
+                    regs.SetRegisterToInteger(instr.gpr0, true, 0, "sizes.x", 1, 1);
+                    regs.SetRegisterToInteger(instr.gpr0.Value() + 1, true, 0, "sizes.y", 1, 1);
+                    regs.SetRegisterToInteger(instr.gpr0.Value() + 2, true, 0, "0", 1, 1);
+                    regs.SetRegisterToInteger(instr.gpr0.Value() + 3, true, 0, mip_level, 1, 1);
                    break;
                }
                default: {
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture query type: {}",
+                    UNIMPLEMENTED_MSG("Unhandled texture query type: {}",
-                                 static_cast<u32>(instr.txq.query_type.Value()));
+                                      static_cast<u32>(instr.txq.query_type.Value()));
-                    UNREACHABLE();
                }
                }
+                --shader.scope;
+                shader.AddLine('}');
                break;
            }
            case OpCode::Id::TMML: {
-                ASSERT_MSG(!instr.tmml.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
+                UNIMPLEMENTED_IF_MSG(instr.tmml.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
-                           "NODEP is not implemented");
+                                     "NODEP is not implemented");
-                ASSERT_MSG(!instr.tmml.UsesMiscMode(Tegra::Shader::TextureMiscMode::NDV),
+                UNIMPLEMENTED_IF_MSG(instr.tmml.UsesMiscMode(Tegra::Shader::TextureMiscMode::NDV),
-                           "NDV is not implemented");
+                                     "NDV is not implemented");
                const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                const bool is_array = instr.tmml.array != 0;
@@ -3021,9 +2986,7 @@ private:
                    break;
                }
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
+                    UNIMPLEMENTED_MSG("Unhandled texture type {}", static_cast<u32>(texture_type));
-                                 static_cast<u32>(texture_type));
-                    UNREACHABLE();
                    // Fallback to interpreting as a 2D texture for now
                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
@@ -3046,8 +3009,7 @@ private:
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled memory instruction: {}", opcode->get().GetName());
+                UNIMPLEMENTED_MSG("Unhandled memory instruction: {}", opcode->get().GetName());
-                UNREACHABLE();
            }
            }
            break;
@@ -3133,7 +3095,7 @@ private:
            break;
        }
        case OpCode::Type::HalfSetPredicate: {
-            ASSERT_MSG(instr.hsetp2.ftz == 0, "Unimplemented");
+            UNIMPLEMENTED_IF(instr.hsetp2.ftz != 0);
            const std::string op_a =
                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hsetp2.type_a,
@@ -3178,6 +3140,9 @@ private:
            break;
        }
        case OpCode::Type::PredicateSetRegister: {
+            UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                 "Condition codes generation in PSET is not implemented");
            const std::string op_a =
                GetPredicateCondition(instr.pset.pred12, instr.pset.neg_pred12 != 0);
            const std::string op_b =
@@ -3198,12 +3163,6 @@ private:
                const std::string value = '(' + result + ") ? 1.0 : 0.0";
                regs.SetRegisterToFloat(instr.gpr0, 0, value, 1, 1);
            }
-            if (instr.generates_cc) {
-                LOG_CRITICAL(HW_GPU, "PSET Generates an unhandled Control Code");
-                UNREACHABLE();
-            }
            break;
        }
        case OpCode::Type::PredicateSetPredicate: {
@@ -3241,21 +3200,19 @@ private:
                const std::string pred =
                    GetPredicateCondition(instr.csetp.pred39, instr.csetp.neg_pred39 != 0);
                const std::string combiner = GetPredicateCombiner(instr.csetp.op);
-                const std::string control_code = regs.GetControlCode(instr.csetp.cc);
+                const std::string condition_code = regs.GetConditionCode(instr.csetp.cc);
                if (instr.csetp.pred3 != static_cast<u64>(Pred::UnusedIndex)) {
                    SetPredicate(instr.csetp.pred3,
-                                 '(' + control_code + ") " + combiner + " (" + pred + ')');
+                                 '(' + condition_code + ") " + combiner + " (" + pred + ')');
                }
                if (instr.csetp.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
                    SetPredicate(instr.csetp.pred0,
-                                 "!(" + control_code + ") " + combiner + " (" + pred + ')');
+                                 "!(" + condition_code + ") " + combiner + " (" + pred + ')');
                }
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled predicate instruction: {}",
+                UNIMPLEMENTED_MSG("Unhandled predicate instruction: {}", opcode->get().GetName());
-                             opcode->get().GetName());
-                UNREACHABLE();
            }
            }
            break;
@@ -3335,7 +3292,7 @@ private:
            break;
        }
        case OpCode::Type::HalfSet: {
-            ASSERT_MSG(instr.hset2.ftz == 0, "Unimplemented");
+            UNIMPLEMENTED_IF(instr.hset2.ftz != 0);
            const std::string op_a =
                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hset2.type_a,
@@ -3379,15 +3336,17 @@ private:
            break;
        }
        case OpCode::Type::Xmad: {
-            ASSERT_MSG(!instr.xmad.sign_a, "Unimplemented");
+            UNIMPLEMENTED_IF(instr.xmad.sign_a);
-            ASSERT_MSG(!instr.xmad.sign_b, "Unimplemented");
+            UNIMPLEMENTED_IF(instr.xmad.sign_b);
+            UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                 "Condition codes generation in XMAD is not implemented");
            std::string op_a{regs.GetRegisterAsInteger(instr.gpr8, 0, instr.xmad.sign_a)};
            std::string op_b;
            std::string op_c;
            // TODO(bunnei): Needs to be fixed once op_a or op_b is signed
-            ASSERT_MSG(instr.xmad.sign_a == instr.xmad.sign_b, "Unimplemented");
+            UNIMPLEMENTED_IF(instr.xmad.sign_a != instr.xmad.sign_b);
            const bool is_signed{instr.xmad.sign_a == 1};
            bool is_merge{};
@@ -3420,8 +3379,7 @@ private:
                break;
            }
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled XMAD instruction: {}", opcode->get().GetName());
+                UNIMPLEMENTED_MSG("Unhandled XMAD instruction: {}", opcode->get().GetName());
-                UNREACHABLE();
            }
            }
@@ -3457,9 +3415,8 @@ private:
                op_c = "((" + op_c + ") + (" + src2 + "<< 16))";
                break;
            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled XMAD mode: {}",
+                UNIMPLEMENTED_MSG("Unhandled XMAD mode: {}",
-                             static_cast<u32>(instr.xmad.mode.Value()));
+                                  static_cast<u32>(instr.xmad.mode.Value()));
-                UNREACHABLE();
            }
            }
@@ -3469,25 +3426,19 @@ private:
            }
            regs.SetRegisterToInteger(instr.gpr0, is_signed, 0, sum, 1, 1);
-            if (instr.generates_cc) {
-                LOG_CRITICAL(HW_GPU, "XMAD Generates an unhandled Control Code");
-                UNREACHABLE();
-            }
            break;
        }
        default: {
            switch (opcode->get().GetId()) {
            case OpCode::Id::EXIT: {
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
+                                     "EXIT condition code used: {}", static_cast<u32>(cc));
                if (stage == Maxwell3D::Regs::ShaderStage::Fragment) {
                    EmitFragmentOutputsWrite();
                }
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "EXIT Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
                switch (instr.flow.cond) {
                case Tegra::Shader::FlowCondition::Always:
                    shader.AddLine("return true;");
@@ -3502,26 +3453,24 @@ private:
                case Tegra::Shader::FlowCondition::Fcsm_Tr:
                    // TODO(bunnei): What is this used for? If we assume this conditon is not
                    // satisifed, dual vertex shaders in Farming Simulator make more sense
-                    LOG_CRITICAL(HW_GPU, "Skipping unknown FlowCondition::Fcsm_Tr");
+                    UNIMPLEMENTED_MSG("Skipping unknown FlowCondition::Fcsm_Tr");
                    break;
                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled flow condition: {}",
+                    UNIMPLEMENTED_MSG("Unhandled flow condition: {}",
-                                 static_cast<u32>(instr.flow.cond.Value()));
+                                      static_cast<u32>(instr.flow.cond.Value()));
-                    UNREACHABLE();
                }
                break;
            }
            case OpCode::Id::KIL: {
-                ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
+                UNIMPLEMENTED_IF(instr.flow.cond != Tegra::Shader::FlowCondition::Always);
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
+                                     "KIL condition code used: {}", static_cast<u32>(cc));
                // Enclose "discard" in a conditional, so that GLSL compilation does not complain
                // about unexecuted instructions that may follow this.
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "KIL Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
                shader.AddLine("if (true) {");
                ++shader.scope;
                shader.AddLine("discard;");
@@ -3531,7 +3480,8 @@ private:
                break;
            }
            case OpCode::Id::OUT_R: {
-                ASSERT(instr.gpr20.Value() == Register::ZeroIndex);
+                UNIMPLEMENTED_IF_MSG(instr.gpr20.Value() != Register::ZeroIndex,
+                                     "Stream buffer is not supported");
                ASSERT_MSG(stage == Maxwell3D::Regs::ShaderStage::Geometry,
                           "OUT is expected to be used in a geometry shader.");
@@ -3558,18 +3508,17 @@ private:
                    break;
                }
                default: {
-                    LOG_CRITICAL(HW_GPU, "Unhandled system move: {}",
+                    UNIMPLEMENTED_MSG("Unhandled system move: {}",
-                                 static_cast<u32>(instr.sys20.Value()));
+                                      static_cast<u32>(instr.sys20.Value()));
-                    UNREACHABLE();
                }
                }
                break;
            }
            case OpCode::Id::ISBERD: {
-                ASSERT(instr.isberd.o == 0);
+                UNIMPLEMENTED_IF(instr.isberd.o != 0);
-                ASSERT(instr.isberd.skew == 0);
+                UNIMPLEMENTED_IF(instr.isberd.skew != 0);
-                ASSERT(instr.isberd.shift == Tegra::Shader::IsberdShift::None);
+                UNIMPLEMENTED_IF(instr.isberd.shift != Tegra::Shader::IsberdShift::None);
-                ASSERT(instr.isberd.mode == Tegra::Shader::IsberdMode::None);
+                UNIMPLEMENTED_IF(instr.isberd.mode != Tegra::Shader::IsberdMode::None);
                ASSERT_MSG(stage == Maxwell3D::Regs::ShaderStage::Geometry,
                           "ISBERD is expected to be used in a geometry shader.");
                LOG_WARNING(HW_GPU, "ISBERD instruction is incomplete");
@@ -3577,13 +3526,13 @@ private:
                break;
            }
            case OpCode::Id::BRA: {
-                ASSERT_MSG(instr.bra.constant_buffer == 0,
+                UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
-                           "BRA with constant buffers are not implemented");
+                                     "BRA with constant buffers are not implemented");
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-                    LOG_CRITICAL(HW_GPU, "BRA Control Code used: {}", static_cast<u32>(cc));
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
-                    UNREACHABLE();
+                                     "BRA condition code used: {}", static_cast<u32>(cc));
-                }
                const u32 target = offset + instr.bra.GetBranchTarget();
                shader.AddLine("{ jmp_to = " + std::to_string(target) + "u; break; }");
                break;
@@ -3606,7 +3555,8 @@ private:
                // The SSY opcode tells the GPU where to re-converge divergent execution paths, it
                // sets the target of the jump that the SYNC instruction will make. The SSY opcode
                // has a similar structure to the BRA opcode.
-                ASSERT_MSG(instr.bra.constant_buffer == 0, "Constant buffer flow is not supported");
+                UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
+                                     "Constant buffer flow is not supported");
                const u32 target = offset + instr.bra.GetBranchTarget();
                EmitPushToFlowStack(target);
@@ -3616,29 +3566,28 @@ private:
                // PBK pushes to a stack the address where BRK will jump to. This shares stack with
                // SSY but using SYNC on a PBK address will kill the shader execution. We don't
                // emulate this because it's very unlikely a driver will emit such invalid shader.
-                ASSERT_MSG(instr.bra.constant_buffer == 0, "Constant buffer PBK is not supported");
+                UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
+                                     "Constant buffer PBK is not supported");
                const u32 target = offset + instr.bra.GetBranchTarget();
                EmitPushToFlowStack(target);
                break;
            }
            case OpCode::Id::SYNC: {
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
+                                     "SYNC condition code used: {}", static_cast<u32>(cc));
                // The SYNC opcode jumps to the address previously set by the SSY opcode
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "SYNC Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
                EmitPopFromFlowStack();
                break;
            }
            case OpCode::Id::BRK: {
                // The BRK opcode jumps to the address previously set by the PBK opcode
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
+                const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
+                UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T,
-                    LOG_CRITICAL(HW_GPU, "BRK Control Code used: {}", static_cast<u32>(cc));
+                                     "BRK condition code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
                EmitPopFromFlowStack();
                break;
            }
@@ -3649,6 +3598,9 @@ private:
                break;
            }
            case OpCode::Id::VMAD: {
+                UNIMPLEMENTED_IF_MSG(instr.generates_cc,
+                                     "Condition codes generation in VMAD is not implemented");
                const bool result_signed = instr.video.signed_a == 1 || instr.video.signed_b == 1;
                const std::string op_a = GetVideoOperandA(instr);
                const std::string op_b = GetVideoOperandB(instr);
@@ -3668,11 +3620,6 @@ private:
                regs.SetRegisterToInteger(instr.gpr0, result_signed, 1, result, 1, 1,
                                          instr.vmad.saturate == 1, 0, Register::Size::Word,
                                          instr.vmad.cc);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "VMAD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                break;
            }
            case OpCode::Id::VSETP: {
@@ -3699,10 +3646,7 @@ private:
                }
                break;
            }
-            default: {
+            default: { UNIMPLEMENTED_MSG("Unhandled instruction: {}", opcode->get().GetName()); }
-                LOG_CRITICAL(HW_GPU, "Unhandled instruction: {}", opcode->get().GetName());
-                UNREACHABLE();
-            }
            }
            break;
@@ -3827,6 +3771,7 @@ private:
    Maxwell3D::Regs::ShaderStage stage;
    const std::string& suffix;
    u64 local_memory_size;
+    std::size_t shader_length;
    ShaderWriter shader;
    ShaderWriter declarations;
@@ -3845,9 +3790,10 @@ std::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u
                                              Maxwell3D::Regs::ShaderStage stage,
                                              const std::string& suffix) {
    try {
-        const auto subroutines =
+        ControlFlowAnalyzer analyzer(program_code, main_offset, suffix);
-            ControlFlowAnalyzer(program_code, main_offset, suffix).GetSubroutines();
+        const auto subroutines = analyzer.GetSubroutines();
-        GLSLGenerator generator(subroutines, program_code, main_offset, stage, suffix);
+        GLSLGenerator generator(subroutines, program_code, main_offset, stage, suffix,
+                                analyzer.GetShaderLength());
        return ProgramResult{generator.GetShaderCode(), generator.GetEntries()};
    } catch (const DecompileFail& exception) {
        LOG_ERROR(HW_GPU, "Shader decompilation failed: {}", exception.what());
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.h b/src/video_core/renderer_opengl/gl_shader_gen.h
index 520b9d4e3..b425d98ae 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.h
+++ b/src/video_core/renderer_opengl/gl_shader_gen.h
@@ -163,6 +163,7 @@ private:
 struct ShaderEntries {
    std::vector<ConstBufferEntry> const_buffer_entries;
    std::vector<SamplerEntry> texture_samplers;
+    std::size_t shader_length;
 };
 using ProgramResult = std::pair<std::string, ShaderEntries>;
diff --git a/src/video_core/renderer_opengl/gl_state.cpp b/src/video_core/renderer_opengl/gl_state.cpp
index 9f96b2745..934f4db78 100644
--- a/src/video_core/renderer_opengl/gl_state.cpp
+++ b/src/video_core/renderer_opengl/gl_state.cpp
@@ -233,6 +233,28 @@ void OpenGLState::ApplyStencilTest() const {
        config_stencil(GL_BACK, stencil.back, cur_state.stencil.back);
    }
 }
+// Viewport does not affects glClearBuffer so emulate viewport using scissor test
+void OpenGLState::EmulateViewportWithScissor() {
+    auto& current = viewports[0];
+    if (current.scissor.enabled) {
+        const GLint left = std::max(current.x, current.scissor.x);
+        const GLint right =
+            std::max(current.x + current.width, current.scissor.x + current.scissor.width);
+        const GLint bottom = std::max(current.y, current.scissor.y);
+        const GLint top =
+            std::max(current.y + current.height, current.scissor.y + current.scissor.height);
+        current.scissor.x = std::max(left, 0);
+        current.scissor.y = std::max(bottom, 0);
+        current.scissor.width = std::max(right - left, 0);
+        current.scissor.height = std::max(top - bottom, 0);
+    } else {
+        current.scissor.enabled = true;
+        current.scissor.x = current.x;
+        current.scissor.y = current.y;
+        current.scissor.width = current.width;
+        current.scissor.height = current.height;
+    }
+}
 void OpenGLState::ApplyViewport() const {
    if (GLAD_GL_ARB_viewport_array && geometry_shaders.enabled) {
@@ -242,7 +264,9 @@ void OpenGLState::ApplyViewport() const {
            const auto& updated = viewports[i];
            if (updated.x != current.x || updated.y != current.y ||
                updated.width != current.width || updated.height != current.height) {
-                glViewportIndexedf(i, updated.x, updated.y, updated.width, updated.height);
+                glViewportIndexedf(
+                    i, static_cast<GLfloat>(updated.x), static_cast<GLfloat>(updated.y),
+                    static_cast<GLfloat>(updated.width), static_cast<GLfloat>(updated.height));
            }
            if (updated.depth_range_near != current.depth_range_near ||
                updated.depth_range_far != current.depth_range_far) {
@@ -270,8 +294,7 @@ void OpenGLState::ApplyViewport() const {
        const auto& updated = viewports[0];
        if (updated.x != current.x || updated.y != current.y || updated.width != current.width ||
            updated.height != current.height) {
-            glViewport(static_cast<GLint>(updated.x), static_cast<GLint>(updated.y),
+            glViewport(updated.x, updated.y, updated.width, updated.height);
-                       static_cast<GLsizei>(updated.width), static_cast<GLsizei>(updated.height));
        }
        if (updated.depth_range_near != current.depth_range_near ||
            updated.depth_range_far != current.depth_range_far) {
diff --git a/src/video_core/renderer_opengl/gl_state.h b/src/video_core/renderer_opengl/gl_state.h
index bdc743b0f..032fc43f0 100644
--- a/src/video_core/renderer_opengl/gl_state.h
+++ b/src/video_core/renderer_opengl/gl_state.h
@@ -156,10 +156,10 @@ public:
    } draw;
    struct viewport {
-        GLfloat x;
+        GLint x;
-        GLfloat y;
+        GLint y;
-        GLfloat width;
+        GLint width;
-        GLfloat height;
+        GLint height;
        GLfloat depth_range_near; // GL_DEPTH_RANGE
        GLfloat depth_range_far;  // GL_DEPTH_RANGE
        struct {
@@ -206,6 +206,7 @@ public:
    OpenGLState& ResetBuffer(GLuint handle);
    OpenGLState& ResetVertexArray(GLuint handle);
    OpenGLState& ResetFramebuffer(GLuint handle);
+    void EmulateViewportWithScissor();
 private:
    static OpenGLState cur_state;
diff --git a/src/video_core/renderer_opengl/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index 065b3929c..a8833c06e 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -218,14 +218,19 @@ inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
 inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
    switch (equation) {
    case Maxwell::Blend::Equation::Add:
+    case Maxwell::Blend::Equation::AddGL:
        return GL_FUNC_ADD;
    case Maxwell::Blend::Equation::Subtract:
+    case Maxwell::Blend::Equation::SubtractGL:
        return GL_FUNC_SUBTRACT;
    case Maxwell::Blend::Equation::ReverseSubtract:
+    case Maxwell::Blend::Equation::ReverseSubtractGL:
        return GL_FUNC_REVERSE_SUBTRACT;
    case Maxwell::Blend::Equation::Min:
+    case Maxwell::Blend::Equation::MinGL:
        return GL_MIN;
    case Maxwell::Blend::Equation::Max:
+    case Maxwell::Blend::Equation::MaxGL:
        return GL_MAX;
    }
    LOG_ERROR(Render_OpenGL, "Unimplemented blend equation={}", static_cast<u32>(equation));
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index aad0b07ca..1492e063a 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -304,6 +304,12 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
        gl_framebuffer_data.resize(texture.width * texture.height * 4);
        break;
    default:
+        internal_format = GL_RGBA;
+        texture.gl_format = GL_RGBA;
+        texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+        gl_framebuffer_data.resize(texture.width * texture.height * 4);
+        LOG_CRITICAL(Render_OpenGL, "Unknown framebuffer pixel format: {}",
+                     static_cast<u32>(framebuffer.pixel_format));
        UNREACHABLE();
    }
diff --git a/src/yuzu/applets/software_keyboard.cpp b/src/yuzu/applets/software_keyboard.cpp
index efefb1f99..8a26fdff1 100644
--- a/src/yuzu/applets/software_keyboard.cpp
+++ b/src/yuzu/applets/software_keyboard.cpp
@@ -82,8 +82,8 @@ QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
                           : QString::fromStdU16String(parameters.submit_text),
                       QDialogButtonBox::AcceptRole);
-    connect(buttons, &QDialogButtonBox::accepted, this, &QtSoftwareKeyboardDialog::Submit);
+    connect(buttons, &QDialogButtonBox::accepted, this, &QtSoftwareKeyboardDialog::accept);
-    connect(buttons, &QDialogButtonBox::rejected, this, &QtSoftwareKeyboardDialog::Reject);
+    connect(buttons, &QDialogButtonBox::rejected, this, &QtSoftwareKeyboardDialog::reject);
    layout->addWidget(header_label);
    layout->addWidget(sub_label);
    layout->addWidget(guide_label);
@@ -96,16 +96,16 @@ QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
 QtSoftwareKeyboardDialog::~QtSoftwareKeyboardDialog() = default;
-void QtSoftwareKeyboardDialog::Submit() {
+void QtSoftwareKeyboardDialog::accept() {
    ok = true;
    text = line_edit->text().toStdU16String();
-    accept();
+    QDialog::accept();
 }
-void QtSoftwareKeyboardDialog::Reject() {
+void QtSoftwareKeyboardDialog::reject() {
    ok = false;
    text.clear();
-    accept();
+    QDialog::reject();
 }
 std::u16string QtSoftwareKeyboardDialog::GetText() const {
@@ -129,13 +129,13 @@ QtSoftwareKeyboard::~QtSoftwareKeyboard() = default;
 void QtSoftwareKeyboard::RequestText(std::function<void(std::optional<std::u16string>)> out,
                                     Core::Frontend::SoftwareKeyboardParameters parameters) const {
-    text_output = out;
+    text_output = std::move(out);
    emit MainWindowGetText(parameters);
 }
 void QtSoftwareKeyboard::SendTextCheckDialog(std::u16string error_message,
                                             std::function<void()> finished_check) const {
-    this->finished_check = finished_check;
+    this->finished_check = std::move(finished_check);
    emit MainWindowTextCheckDialog(error_message);
 }
diff --git a/src/yuzu/applets/software_keyboard.h b/src/yuzu/applets/software_keyboard.h
index 73f56714f..c63720ba4 100644
--- a/src/yuzu/applets/software_keyboard.h
+++ b/src/yuzu/applets/software_keyboard.h
@@ -33,8 +33,8 @@ public:
                             Core::Frontend::SoftwareKeyboardParameters parameters);
    ~QtSoftwareKeyboardDialog() override;
-    void Submit();
+    void accept() override;
-    void Reject();
+    void reject() override;
    std::u16string GetText() const;
    bool GetStatus() const;
@@ -70,11 +70,10 @@ signals:
    void MainWindowGetText(Core::Frontend::SoftwareKeyboardParameters parameters) const;
    void MainWindowTextCheckDialog(std::u16string error_message) const;
-public slots:
+private:
    void MainWindowFinishedText(std::optional<std::u16string> text);
    void MainWindowFinishedCheckDialog();
-private:
    mutable std::function<void(std::optional<std::u16string>)> text_output;
    mutable std::function<void()> finished_check;
 };
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index e24ed5f2b..83ebbd1fe 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -432,6 +432,7 @@ void Config::ReadValues() {
    Settings::values.use_gdbstub = qt_config->value("use_gdbstub", false).toBool();
    Settings::values.gdbstub_port = qt_config->value("gdbstub_port", 24689).toInt();
    Settings::values.program_args = qt_config->value("program_args", "").toString().toStdString();
+    Settings::values.dump_exefs = qt_config->value("dump_exefs", false).toBool();
    Settings::values.dump_nso = qt_config->value("dump_nso", false).toBool();
    qt_config->endGroup();
@@ -638,6 +639,7 @@ void Config::SaveValues() {
    qt_config->setValue("use_gdbstub", Settings::values.use_gdbstub);
    qt_config->setValue("gdbstub_port", Settings::values.gdbstub_port);
    qt_config->setValue("program_args", QString::fromStdString(Settings::values.program_args));
+    qt_config->setValue("dump_exefs", Settings::values.dump_exefs);
    qt_config->setValue("dump_nso", Settings::values.dump_nso);
    qt_config->endGroup();
diff --git a/src/yuzu/configuration/configure_debug.cpp b/src/yuzu/configuration/configure_debug.cpp
index fd5876b41..aa7de7b54 100644
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@@ -34,6 +34,7 @@ void ConfigureDebug::setConfiguration() {
    ui->toggle_console->setChecked(UISettings::values.show_console);
    ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
+    ui->dump_exefs->setChecked(Settings::values.dump_exefs);
    ui->dump_decompressed_nso->setChecked(Settings::values.dump_nso);
 }
@@ -43,6 +44,7 @@ void ConfigureDebug::applyConfiguration() {
    UISettings::values.show_console = ui->toggle_console->isChecked();
    Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
    Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
+    Settings::values.dump_exefs = ui->dump_exefs->isChecked();
    Settings::values.dump_nso = ui->dump_decompressed_nso->isChecked();
    Debugger::ToggleConsole();
    Log::Filter filter;
diff --git a/src/yuzu/configuration/configure_debug.ui b/src/yuzu/configuration/configure_debug.ui
index 9c5b702f8..758a92335 100644
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@@ -145,6 +145,16 @@
        </property>
       </widget>
      </item>
+      <item>
+       <widget class="QCheckBox" name="dump_exefs">
+        <property name="whatsThis">
+         <string>When checked, any game that yuzu loads will have its ExeFS dumped to the yuzu/dump directory.</string>
+        </property>
+        <property name="text">
+         <string>Dump ExeFS</string>
+        </property>
+       </widget>
+      </item>
     </layout>
    </widget>
   </item>
diff --git a/src/yuzu/configuration/configure_graphics.ui b/src/yuzu/configuration/configure_graphics.ui
index 91fcad994..e278cdd05 100644
--- a/src/yuzu/configuration/configure_graphics.ui
+++ b/src/yuzu/configuration/configure_graphics.ui
@@ -23,31 +23,31 @@
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <item>
-          <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <layout class="QHBoxLayout" name="horizontalLayout_2">
-            <item>
+          <item>
-              <widget class="QCheckBox" name="toggle_frame_limit">
+           <widget class="QCheckBox" name="toggle_frame_limit">
-                <property name="text">
+            <property name="text">
-                  <string>Limit Speed Percent</string>
+             <string>Limit Speed Percent</string>
-                </property>
+            </property>
-              </widget>
+           </widget>
-            </item>
+          </item>
-            <item>
+          <item>
-              <widget class="QSpinBox" name="frame_limit">
+           <widget class="QSpinBox" name="frame_limit">
-                <property name="suffix">
+            <property name="suffix">
-                  <string>%</string>
+             <string>%</string>
-                </property>
+            </property>
-                <property name="minimum">
+            <property name="minimum">
-                  <number>1</number>
+             <number>1</number>
-                </property>
+            </property>
-                <property name="maximum">
+            <property name="maximum">
-                  <number>9999</number>
+             <number>9999</number>
-                </property>
+            </property>
-                <property name="value">
+            <property name="value">
-                  <number>100</number>
+             <number>100</number>
-                </property>
+            </property>
-              </widget>
+           </widget>
-            </item>
+          </item>
-          </layout>
+         </layout>
        </item>
        <item>
         <widget class="QCheckBox" name="use_accurate_gpu_emulation">
@@ -61,7 +61,7 @@
          <item>
           <widget class="QLabel" name="label">
            <property name="text">
-             <string>Internal Resolution:(Currently does nothing.)</string>
+             <string>Internal Resolution</string>
            </property>
           </widget>
          </item>
@@ -96,27 +96,27 @@
          </item>
         </layout>
        </item>
-         <item>
+        <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_6">
+         <layout class="QHBoxLayout" name="horizontalLayout_6">
-             <item>
+          <item>
-               <widget class="QLabel" name="bg_label">
+           <widget class="QLabel" name="bg_label">
-                 <property name="text">
+            <property name="text">
-                   <string>Background Color:</string>
+             <string>Background Color:</string>
-                 </property>
+            </property>
-               </widget>
+           </widget>
-             </item>
+          </item>
-             <item>
+          <item>
-               <widget class="QPushButton" name="bg_button">
+           <widget class="QPushButton" name="bg_button">
-                 <property name="maximumSize">
+            <property name="maximumSize">
-                   <size>
+             <size>
-                     <width>40</width>
+              <width>40</width>
-                     <height>16777215</height>
+              <height>16777215</height>
-                   </size>
+             </size>
-                 </property>
+            </property>
-               </widget>
+           </widget>
-             </item>
+          </item>
-           </layout>
+         </layout>
-         </item>
+        </item>
       </layout>
      </widget>
     </item>
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index c66353a65..097c1fbe3 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -366,6 +366,7 @@ void Config::ReadValues() {
    Settings::values.gdbstub_port =
        static_cast<u16>(sdl2_config->GetInteger("Debugging", "gdbstub_port", 24689));
    Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
+    Settings::values.dump_exefs = sdl2_config->GetBoolean("Debugging", "dump_exefs", false);
    Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
    // Web Service
diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h
index ecf625e7b..d73669f36 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -206,6 +206,8 @@ log_filter = *:Trace
 # Port for listening to GDB connections.
 use_gdbstub=false
 gdbstub_port=24689
+# Determines whether or not yuzu will dump the ExeFS of all games it attempts to load while loading them
+dump_exefs=false
 # Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
 dump_nso=false